;;============================================================

;;本代码由田憬源提供和整理。

;;============================================================

;;1. 设置全局变量、智能体种类、区域属性、智能体属性

;;============================================================

;;设置全局变量
globals [  ;;设置全局变量
  rural_workers_created?  ;;务工人员创造状态
  worker_link_created?  ;;务工人员与村民链接创造状态
  gentry_link_created?  ;;乡村精英创造状态
  rural_gentry_created?  ;;乡村精英与村民链接创造状态
  urban_volunteers_created?  ;;城市志愿者创造状态
  volunteer_link_created?  ;;城市志愿者与村民链接创造状态
  initial_ave_u_knowledge_reported?  ;;初始城市平均知识量汇报状态
  initial_ave_r_knowledge_reported?  ;;初始乡村平均知识量汇报状态
  initial_u_r_knowledge_gap_reported?  ;;初始城乡知识沟汇报状态
  initial_average_urban_knowledge  ;;初始城市平均知识量
  initial_average_rural_knowledge  ;;初始乡村平均知识量
  initial_urban_rural_knowledge_gap  ;;初始城乡知识沟
  max_urban_rural_knowledge_gap  ;;城乡知识沟最大值
  initial_u_gini_reported?  ;;初始城市基尼系数汇报状态
  initial_r_gini_reported?  ;;初始乡村基尼系数汇报状态
  gini_citizens  ;;实时城市基尼系数汇报状态
  gini_villagers  ;;实时乡村基尼系数汇报状态
  max_gini_citizens  ;;城市基尼系数最大值
  max_gini_villagers  ;;乡村基尼系数最大值
  total_knowledge  ;;知识总量
  results_filepath ;;文件存储路径
]

;;设置智能体种类
breed [citizens citizen]  ;;设置市民种类
breed [villagers villager]  ;;设置村民种类
breed [rural_workers rural_worker]  ;;设置务工人员种类
breed [rural_gentrys rural_gentry]  ;;设置乡村精英种类
breed [urban_volunteers urban_volunteer]  ;;设置城市志愿者种类

;;设置区域属性
patches-own [  ;;设置区域属性
  region_type  ;;区域类型
  station_city  ;;城市互联网普及水平
  station_countryside  ;;乡村互联网普及水平
]

;;设置智能体属性
turtles-own [  ;;设置智能体属性
  education_citizen  ;;市民教育水平
  education_villager  ;;村民教育水平
  digital_access  ;;互联网接入水平
  digital_usage  ;;互联网使用水平
  digital_capability  ;;数字能力
  initial_capability  ;;初始数字能力
  current_capability  ;;实时数字能力
  vision  ;;视野
  information  ;;信息量
  knowledge  ;;知识量
]

;;============================================================

;;2. 设置循环运行按钮

;;============================================================

;;设置循环运行
to start  ;;设置循环运行
  repeat 10 [  ;;重复10次
    setup  ;;每轮设置1次初始状态
    while [ticks <= 1000] [  ;;每轮运行到1000时间步停止
      go  ;;在1000时间步内持续运行
    ]
    save_data  ;;每轮保存1次数据
  ]
end  ;;结束循环运行

;;============================================================

;;3. 设置初始状态
;;设置城乡分离与城乡互动模式下的智能体和区域外观、属性，通过互联网接入水平、使用水平与初始信息量和知识量相关联

;;============================================================

;;设置初始状态
to setup  ;;设置初始状态
  clear-all  ;;清空全局
  set max_urban_rural_knowledge_gap 0  ;;设置城乡最大知识沟为0
  set max_gini_villagers 0  ;;设置村民最大基尼系数为0

  ;;设置“城乡分离”模式的模型属性
  if urban_rural_mode = "separated" [  ;;当设置为“城乡分离”模式时
    setup_separated  ;;设置“城乡分离”的区域和智能体属性
    setup_access_separated  ;;设置“城乡分离”的互联网接入沟
    setup_usage_separated  ;;设置“城乡分离”的互联网使用沟
    setup_capability_separated  ;;设置“城乡分离”的互联网运用能力和智能体知识量（接入和使用综合决定）

    ;;存储初始城市平均知识量
    set initial_ave_u_knowledge_reported? false  ;;设置初始城市平均知识量汇报情况为“否”
    set initial_average_urban_knowledge initial_ave_u_knowledge  ;;存储初始城市平均知识量

    ;;存储初始乡村平均知识量
    set initial_ave_r_knowledge_reported? false  ;;设置初始乡村平均知识量汇报情况为“否”
    set initial_average_rural_knowledge initial_ave_r_knowledge  ;;存储初始乡村平均知识量

    ;;存储初始城乡知识沟
    set initial_u_r_knowledge_gap_reported? false  ;;设置初始城乡知识沟汇报情况为“否”
    set initial_urban_rural_knowledge_gap initial_u_r_knowledge_gap  ;;存储初始城乡知识沟
  ]

  ;;设置“城乡互动”模式的模型属性
  if urban_rural_mode = "merged" [  ;;当设置为“城乡互动”模式时
    setup_merged  ;;设置“城乡互动”的区域和智能体属性
    setup_access_merged  ;;设置“城乡互动”的互联网接入沟
    setup_usage_merged  ;;设置“城乡互动”的互联网使用沟
    setup_capability_merged  ;;设置“城乡互动”的互联网运用能力（接入和使用综合决定）

    ;;设置“城乡互动”不同主体初始出现情况为“否”，后续通过条件判断以出现主体
    set rural_workers_created? false  ;;设置务工人员创造情况为“否”
    set worker_link_created? false  ;;设置务工人员与村民的链接创造情况为“否”
    set rural_gentry_created? false  ;;设置乡村精英创造情况为“否”
    set gentry_link_created? false   ;;设置乡村精英与村民的链接创造情况为“否”
    set urban_volunteers_created? false  ;;设置城市志愿者创造情况为“否”
    set volunteer_link_created? false  ;;设置城市志愿者与村民的链接创造情况为“否”

    ;;存储初始城市平均知识量
    set initial_ave_u_knowledge_reported? false  ;;设置初始城市平均知识量汇报情况为“否”
    set initial_average_urban_knowledge initial_ave_u_knowledge  ;;存储初始城市平均知识量

    ;;存储初始乡村平均知识量
    set initial_ave_r_knowledge_reported? false  ;;设置初始乡村平均知识量汇报情况为“否”
    set initial_average_rural_knowledge initial_ave_r_knowledge  ;;存储初始乡村平均知识量

    ;;存储初始城乡知识沟
    set initial_u_r_knowledge_gap_reported? false  ;;设置初始城乡知识沟汇报情况为“否”
    set initial_urban_rural_knowledge_gap initial_u_r_knowledge_gap  ;;存储初始城乡知识沟
  ]
  reset-ticks  ;;重置时间步，以确保每次时间推进均从零开始
end

;;设置“城乡分离”的区域和智能体属性
to setup_separated  ;;设置“城乡分离”的区域和智能体属性
  setup_border  ;;设置城乡边界
  setup_district_separated  ;;设置“城乡分离”的城乡区域属性
  setup_district_offer_separated  ;;设置“城乡分离”的城乡区域互联网接入水平
  setup_resident_separated  ;;设置“城乡分离”的城乡居民属性
  setup_resident_own_separated  ;;设置“城乡分离”的城乡居民教育水平
end  ;;结束设置“城乡分离”的区域和智能体属性

;;设置城乡边界
to setup_border ;;设置城乡边界
  ask patches [  ;;针对区域发出指令
    if pxcor >= -100 and pxcor <= 100 and pycor >= -50 and pycor < -49 [  ;;-100<=x<=100，-50<=y<-49的区域，即下边界
      set pcolor black  ;;设置为黑色
    ]
    if pxcor >= -100 and pxcor <= 100 and pycor > 49 and pycor <= 50 [  ;;-100<=x<=100，49<y<=50的区域，即上边界
      set pcolor black  ;;设置为黑色
    ]
    if pxcor > 99 and pxcor <= 100 and pycor >= -50 and pycor <= 50 [  ;;99<x<=100，-50<=y<=50的区域，即右边界
      set pcolor black  ;;设置为黑色
    ]
    if pxcor < -99 and pxcor >= -100 and pycor >= -50 and pycor <= 50 [  ;;-100<=x<-99，-50<=y<=50的区域，即左边界
      set pcolor black  ;;设置为黑色
    ]
    if pxcor > -1 and pxcor < 1 and pycor >= -50 and pycor <= 50 [  ;;-1<x<1，-50<=y<=50，即中间城乡边界
      set pcolor black  ;;设置为黑色
    ]
  ]
end  ;;结束设置城乡边界

;;设置“城乡分离”的城乡区域属性
to setup_district_separated ;;设置城乡区域属性
  ask patches [  ;;针对区域发出指令
    if pxcor > 0 and pxcor < 100 and pycor > -50 and pycor < 50 [  ;;0<x<100，-50<y<50的区域，即右边的城市区域
      set pcolor 48  ;;设置颜色为48号
      set region_type "city"  ;;设置区域名称为“city”
    ]
    if pxcor < 0 and pxcor > -100 and pycor > -50 and pycor < 50 [  ;;-100<x<0，-50<y<50的区域，即左边的乡村区域
      set pcolor 68  ;;设置颜色为68号
      set region_type "countryside"  ;;设置区域名称为“countryside”
    ]
  ]
end  ;;结束设置“城乡分离”的城乡区域属性

;;设置“城乡分离”的城乡区域互联网接入水平
to setup_district_offer_separated  ;;设置“城乡分离”的城乡区域互联网接入水平
  ;;设置城市互联网普及不同水平的比例
  ask patches with [region_type = "city"] [  ;;针对区域名称为“city”的区域发出指令
    let rand random-float 1  ;; 生成一个 [0, 1) 的随机数
    ifelse rand < 0.57 [   ;;当概率为57%时，即高水平区域占比为57%
      set station_city 7 + random 4  ;;设置互联网普及水平为固定的7+随机的[0,4)，即高水平为[7,10]
    ] [
       ifelse rand < 0.74 [    ;;当概率没有落在57%但落在74%时，即概率为17%，中水平区域占比为17%
        set station_city 4 + random 3  ;;设置互联网普及水平为固定的4+随机的[0,3)，即高水平为[4,7)
      ] [
        ifelse rand < 0.85 [  ;;当概率没有落在74%但落在85%时，即概率为11%，低水平区域占比为11%
          set station_city 1 + random 3  ;;设置互联网普及水平为固定的1+随机的[0,3)，即高水平为[1,4)
        ] [
          set station_city 0  ;;剩余的15%为无互联网接入，设置互联网普及水平为0
        ]
      ]
    ]
  ]

  ;;设置乡村互联网普及不同水平的比例
  ask patches with [region_type = "countryside"] [  ;;针对区域名称为“countryside”的区域发出指令
    let rand random-float 1  ;; 生成一个 [0, 1) 的随机数
    ifelse rand < 0.37  [  ;;当概率为37%时，即高水平区域占比为37%
      set station_countryside 7 + random 3  ;;设置互联网普及水平为固定的7+随机的[0,4)，即高水平为[7,10]
    ] [
        ifelse rand < 0.52  [  ;;当概率没有落在37%但落在52%时，即概率为15%，中水平区域占比为15%
          set station_countryside 4 + random 3  ;;设置互联网普及水平为固定的4+随机的[0,3)，即高水平为[4,7)
    ] [
        ifelse rand < 0.66 [  ;;当概率没有落在52%但落在66%时，即概率为14%，中水平区域占比为14%
          set station_countryside 1 + random 3  ;;设置互联网普及水平为固定的1+随机的[0,3)，即高水平为[1,4)
        ] [
          set station_countryside 0  ;;剩余的34%为无互联网接入，设置互联网普及水平为0
        ]
      ]
    ]
  ]
end  ;;结束设置“城乡分离”的城乡区域互联网接入水平

;;设置“城乡分离”的城乡居民属性
to setup_resident_separated ;;设置“城乡分离”的城乡居民属性
  create-citizens 500 [  ;;创造breed为citizens的500个市民智能体
    let x 3 + random-float 93  ;;设置市民位置在x轴的[3,96)，与边界保持一定距离
    let y -47 + random-float 93  ;;设置市民位置在y轴的[-47,46)，与边界保持一定距离
    setxy x y  ;;设置市民在指定区域内随机分布
    set shape "person"  ;;设置市民形状为“person”
  ]
  create-villagers 500 [  ;;创造breed为villagers的500个村民智能体
    let x -3 + random-float 93 * -1  ;;设置村民位置在x轴的(-96,-3]，与边界保持一定距离
    let y -47 + random-float 93  ;;设置村民位置在y轴的[-47,46)，与边界保持一定距离
    setxy x y  ;;设置村民在指定区域内随机分布
    set shape "person"  ;;设置村民形状为“person”
  ]
end  ;;结束设置“城乡分离”的城乡居民属性

;;设置“城乡分离”的城乡居民教育水平
to setup_resident_own_separated  ;;设置“城乡分离”的城乡居民教育水平
  ;;设置市民不同教育水平的比例
  ask citizens [  ;;针对市民发出指令
    let rand random-float 1  ;; 生成一个 [0, 1) 的随机数
    ifelse rand < 0.28 [   ;;当概率为28%时，即高教育水平市民占比为57%
        set education_citizen 7 + random 4  ;;设置教育水平为固定的7+随机的[0,4)，即高教育水平为[7,10]
    ] [
      ifelse rand < 0.84 [    ;; 56% 概率 - 中水平 (4-6分) (0.28 + 0.56 = 0.84)
        set education_citizen 4 + random 3  ;;设置教育水平为固定的4+随机的[0,3)，即高教育水平为[4,7)
      ] [
        ifelse rand < 0.97 [  ;; 13% 概率 - 低水平 (1-3分) (0.84 + 0.13 = 0.97)
          set education_citizen 1 + random 3  ;;设置教育水平为固定的1+随机的[0,3)，即高教育水平为[1,4)
        ] [
          set education_citizen 0  ;;剩余的33%为无教育水平，设置教育水平为0
        ]
      ]
    ]
  ]

  ;;设置村民不同教育水平的比例
  ask villagers [  ;;针对村民发出指令
    let rand random-float 1  ;; 生成一个 [0, 1) 的随机数
    ifelse rand < 0.07 [   ;;当概率为7%时，即高教育水平村民占比为7%
        set education_villager 7 + random 4  ;;设置教育水平为固定的7+随机的[0,4)，即高教育水平为[7,10]
    ] [
      ifelse rand < 0.64 [   ;;当概率没有落在7%但落在64%时，即概率为57%，中教育水平村民占比为14%
        set education_villager 4 + random 3  ;;设置教育水平为固定的4+随机的[0,3)，即高教育水平为[4,7)
        ] [
        ifelse rand < 0.91 [  ;;当概率没有落在64%但落在91%时，即概率为27%，低教育水平村民占比为27%
          set education_villager 1 + random 3  ;;设置教育水平为固定的1+随机的[0,3)，即高教育水平为[1,4)
        ] [
          set education_villager 0  ;;剩余的9%为无教育水平，设置教育水平为0
        ]
      ]
    ]
  ]
end  ;;结束设置“城乡分离”的城乡居民教育水平

;;设置“城乡分离”的互联网接入沟
to setup_access_separated  ;;设置“城乡分离”的互联网接入沟
  ask citizens [  ;;针对市民发出指令
    set digital_access [station_city] of patch-here  ;;将区域属性迁移到智能体，设置市民互联网接入水平为区域互联网普及水平*
  ]
  ask villagers [  ;;针对村民发出指令
    set digital_access [station_countryside] of patch-here  ;;将区域属性迁移到智能体，设置村民互联网接入水平为区域互联网普及水平
  ]
end  ;;结束设置“城乡分离”的互联网接入沟

;;设置“城乡分离”的互联网使用沟
to setup_usage_separated  ;;设置“城乡分离”的互联网使用沟
  ask citizens [  ;;针对市民发出指令
    set digital_usage education_citizen   ;;设置市民互联网使用水平为教育水平
  ]
  ask villagers [  ;;针对村民发出指令
    set digital_usage education_villager   ;;设置村民互联网使用水平为教育水平
  ]
end  ;;结束设置“城乡分离”的互联网使用沟

;;设置“城乡分离”的互联网运用能力和智能体知识量（接入和使用综合决定），并针对不同能力的智能体赋予不同外观
to setup_capability_separated  ;;设置“城乡分离”的互联网运用能力（接入和使用综合决定）
  ;;设置市民知识量
  ask citizens [  ;;针对市民发出指令
    set digital_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.9  ;;设置市民互联网使用能力为互联网接入水平与使用水平共同作用下的线性增长，使用水平影响更大，并赋予城市系数
    set initial_capability digital_capability  ;;将互联网使用能力设置为初始能力
    set current_capability digital_capability  ;;将互联网使用能力设置为当下能力
    set information initial_capability  ;;将初始能力转化为信息量
    set knowledge (information + 0.0001)  ;;设置知识量为信息量的线性增长，赋予初始值以避免为0
  ]

  ;;对市民按知识量排序、分类、设置外观
  let sorted_citizens sort-on [knowledge] citizens  ;;按照市民知识量升序排序
  let citizen_count count citizens ;;统计市民数量
  let top_tier sublist sorted_citizens (citizen_count * 0.7) citizen_count  ;;按照知识量升序排序后，靠后的即为知识量多的智能体。设置高知识量的市民为第70%+1个智能体到最后一个智能体，即后30%（索引为70-99）
  let mid_tier sublist sorted_citizens (citizen_count * 0.3) (citizen_count * 0.7)  ;;设置中知识量的市民为第30%+1个智能体到第70%个智能体，即中间的40%（索引为30-69）
  let low_tier sublist sorted_citizens 0 (citizen_count * 0.3)   ;;设置低知识量的市民为第1个智能体到第30%个智能体，即前30%（索引为0-29）
  ask citizens with [member? self top_tier] [  ;;针对高知识量的市民
    set size 3  ;;尺寸为3
    set color 14  ;;色号为14
  ]
  ask citizens with [member? self mid_tier] [  ;;针对中知识量的市民
    set size 2  ;;尺寸为2
    set color 16  ;;色号为16
  ]
  ask citizens with [member? self low_tier] [  ;;针对低知识量的市民
    set size 1  ;;尺寸为1
    set color 18  ;;色号为18
  ]

  ;;设置村民知识量
  ask villagers [
    set digital_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.7  ;;设置村民互联网使用能力为互联网接入水平与使用水平共同作用下的线性增长，使用水平影响更大，并赋予乡村系数
    set initial_capability digital_capability  ;;将互联网使用能力设置为初始能力
    set current_capability digital_capability  ;;将互联网使用能力设置为当下能力
    set information initial_capability  ;;将初始能力转化为信息量
    set knowledge (information + 0.0001)  ;;设置知识量为信息量的线性增长，赋予初始值以避免为0
  ]

  ;;对村民按知识量排序、分类、设置外观
  let sorted_villagers sort-on [knowledge] villagers  ;;按照村民知识量升序排序
  let villager_count count villagers  ;;统计村民数量
  let v_top_tier sublist sorted_villagers (villager_count * 0.7) villager_count  ;;按照知识量升序排序后，靠后的即为知识量多的智能体。设置高知识量的村民为第70%+1个智能体到最后一个智能体，即后30%（索引为70-99）
  let v_mid_tier sublist sorted_villagers (villager_count * 0.3) (villager_count * 0.7)  ;;设置中知识量的村民为第30%+1个智能体到第70%个智能体，即中间的40%（索引为30-69）
  let v_low_tier sublist sorted_villagers 0 (villager_count * 0.3)  ;;设置低知识量的村民为第1个智能体到第30%个智能体，即前30%（索引为0-29）
  ask villagers with [member? self v_top_tier] [  ;;针对高知识量的村民
    set size 3  ;;尺寸为3
    set color 104  ;;色号为104
  ]
  ask villagers with [member? self v_mid_tier] [  ;;针对中知识量的村民
    set size 2  ;;尺寸为2
    set color 106  ;;色号为106
  ]
  ask villagers with [member? self v_low_tier] [  ;;针对中知识量的村民
    set size 1  ;;尺寸为1
    set color 108  ;;色号为108
  ]
end  ;;结束设置“城乡分离”的互联网运用能力和智能体知识量

;;设置“城乡互动”的区域和智能体属性
to setup_merged  ;;设置“城乡互动”的区域和智能体属性
  setup_district_merged  ;;设置“城乡互动”的城乡区域属性
  setup_district_offer_merged  ;;设置“城乡互动”的城乡区域互联网接入水平
  setup_resident_merged  ;;设置“城乡互动”的城乡居民属性
  setup_resident_own_merged  ;;设置“城乡互动”的城乡居民教育水平
end  ;;结束设置“城乡互动”的区域和智能体属性

;;设置“城乡互动”的城乡区域属性
to setup_district_merged  ;;设置“城乡互动”的城乡区域属性
  ask patches [  ;;针对区域发出指令
    if pxcor >= 0 and pxcor <= 100 and pycor >= -50 and pycor <= 50 [  ;;0<=x<=100，-50<=y<=50的区域，即右边的城市区域
      set pcolor 48  ;;设置颜色为48号
      set region_type "city"  ;;设置区域名称为“city”
    ]
    if pxcor < 0 and pxcor >= -100 and pycor >= -50 and pycor <= 50 [  ;;-100<=x<0，-50<=y<=50的区域，即左边的乡村区域
      set pcolor 68  ;;设置颜色为68号
      set region_type "countryside"  ;;设置区域名称为“countryside”
    ]
  ]
end  ;;结束设置“城乡互动”的城乡区域属性

;;设置“城乡互动”的城乡区域互联网接入水平
to setup_district_offer_merged  ;;设置“城乡互动”的城乡区域互联网接入水平
  ;;设置城市互联网普及不同水平的比例
  ask patches with [region_type = "city"] [  ;;针对区域名称为“city”的区域发出指令
    let rand random-float 1  ;; 生成一个 [0, 1) 的随机数
    ifelse rand < 0.57 [   ;;当概率为57%时，即高水平区域占比为57%
      set station_city 7 + random 4  ;;设置互联网普及水平为固定的7+随机的[0,4)，即高水平为[7,10]
    ] [
       ifelse rand < 0.74 [    ;;当概率没有落在57%但落在74%时，即概率为17%，中水平区域占比为17%
        set station_city 4 + random 3  ;;设置互联网普及水平为固定的4+随机的[0,3)，即高水平为[4,7)
      ] [
        ifelse rand < 0.85 [  ;;当概率没有落在74%但落在85%时，即概率为11%，低水平区域占比为11%
          set station_city 1 + random 3  ;;设置互联网普及水平为固定的1+随机的[0,3)，即高水平为[1,4)
        ] [
          set station_city 0  ;;剩余的15%为无互联网接入，设置互联网普及水平为0
        ]
      ]
    ]
  ]

  ;;设置乡村互联网普及不同水平的比例
  ask patches with [region_type = "countryside"] [  ;;针对区域名称为“countryside”的区域发出指令
    let rand random-float 1  ;; 生成一个 [0, 1) 的随机数
    ifelse rand < 0.37  [  ;;当概率为37%时，即高水平区域占比为37%
      set station_countryside 7 + random 3  ;;设置互联网普及水平为固定的7+随机的[0,4)，即高水平为[7,10]
    ] [
        ifelse rand < 0.52  [  ;;当概率没有落在37%但落在52%时，即概率为15%，中水平区域占比为15%
          set station_countryside 4 + random 3  ;;设置互联网普及水平为固定的4+随机的[0,3)，即高水平为[4,7)
    ] [
        ifelse rand < 0.66 [  ;;当概率没有落在52%但落在66%时，即概率为14%，中水平区域占比为14%
          set station_countryside 1 + random 3  ;;设置互联网普及水平为固定的1+随机的[0,3)，即高水平为[1,4)
        ] [
          set station_countryside 0  ;;剩余的34%为无互联网接入，设置互联网普及水平为0
        ]
      ]
    ]
  ]
end  ;;结束设置“城乡互动”的城乡区域互联网接入水平

;;设置“城乡互动”的城乡居民属性
to setup_resident_merged  ;;设置“城乡互动”的城乡居民属性
  create-citizens 500 [  ;;创造breed为citizens的500个市民智能体
    let x 0 + random-float 95  ;;设置市民位置在x轴的[0,95)，消除边界
    let y -47 + random-float 93 ;;设置市民位置在y轴的[-47,46)，与边界保持一定距离
    setxy x y  ;;设置市民在指定区域内随机分布
    set shape "person"  ;;设置市民形状为“person”
  ]
  create-villagers 500 [
    let x -1 + random-float 95 * -1  ;;设置村民位置在x轴的(-96,-1]，消除边界
    let y -47 + random-float 93  ;;设置村民位置在y轴的[-47,46)，与边界保持一定距离
    setxy x y  ;;设置村民在指定区域内随机分布
    set shape "person"  ;;设置村民形状为“person”
  ]
end  ;;结束设置“城乡互动”的城乡居民属性

;;设置“城乡互动”的城乡居民教育水平
to setup_resident_own_merged  ;;设置“城乡互动”的城乡居民教育水平
  ;;设置市民不同教育水平的比例
  ask citizens [  ;;针对市民发出指令
    let rand random-float 1  ;; 生成一个 [0, 1) 的随机数
    ifelse rand < 0.28 [   ;;当概率为28%时，即高教育水平市民占比为57%
        set education_citizen 7 + random 4  ;;设置教育水平为固定的7+随机的[0,4)，即高教育水平为[7,10]
    ] [
      ifelse rand < 0.84 [    ;; 56% 概率 - 中水平 (4-6分) (0.28 + 0.56 = 0.84)
        set education_citizen 4 + random 3  ;;设置教育水平为固定的4+随机的[0,3)，即高教育水平为[4,7)
      ] [
        ifelse rand < 0.97 [  ;; 13% 概率 - 低水平 (1-3分) (0.84 + 0.13 = 0.97)
          set education_citizen 1 + random 3  ;;设置教育水平为固定的1+随机的[0,3)，即高教育水平为[1,4)
        ] [
          set education_citizen 0  ;;剩余的33%为无教育水平，设置教育水平为0
        ]
      ]
    ]
  ]

  ;;设置村民不同教育水平的比例
  ask villagers [  ;;针对村民发出指令
    let rand random-float 1  ;; 生成一个 [0, 1) 的随机数
    ifelse rand < 0.07 [   ;;当概率为7%时，即高教育水平村民占比为7%
        set education_villager 7 + random 4  ;;设置教育水平为固定的7+随机的[0,4)，即高教育水平为[7,10]
    ] [
      ifelse rand < 0.64 [   ;;当概率没有落在7%但落在64%时，即概率为57%，中教育水平村民占比为14%
        set education_villager 4 + random 3  ;;设置教育水平为固定的4+随机的[0,3)，即高教育水平为[4,7)
        ] [
        ifelse rand < 0.91 [  ;;当概率没有落在64%但落在91%时，即概率为27%，低教育水平村民占比为27%
          set education_villager 1 + random 3  ;;设置教育水平为固定的1+随机的[0,3)，即高教育水平为[1,4)
        ] [
          set education_villager 0  ;;剩余的9%为无教育水平，设置教育水平为0
        ]
      ]
    ]
  ]
end  ;;结束设置“城乡互动”的城乡居民教育水平

;;设置“城乡互动”的互联网接入沟
to setup_access_merged  ;;设置“城乡互动”的互联网接入沟
  ask citizens [  ;;针对市民发出指令
    ifelse [station_city] of patch-here != 0 [  ;;如果市民在城市区域，而且区域的互联网普及水平不为0
      set digital_access [station_city] of patch-here  ;;设置互联网接入水平为所在区域的城市互联网普及水平
    ][
      set digital_access [station_countryside] of patch-here  ;;如果市民在乡村区域，互联网接入水平为所在区域的乡村互联网普及水平
    ]
  ]
  ask villagers [  ;;针对村民发出指令
    ifelse [station_countryside] of patch-here != 0 [  ;;如果市民在乡村区域，而且区域的互联网普及水平不为0
      set digital_access [station_countryside] of patch-here  ;;设置互联网接入水平为所在区域的乡村互联网普及水平
    ][
      set digital_access [station_city] of patch-here  ;;设置互联网接入水平为所在区域的城市互联网普及水平
    ]
  ]
end  ;;结束设置“城乡互动”的互联网接入沟

;;设置“城乡互动”的互联网使用沟
to setup_usage_merged  ;;设置“城乡互动”的互联网使用沟
  ask citizens [  ;;针对市民发出指令
    set digital_usage education_citizen  ;;设置市民互联网使用水平为教育水平
  ]
  ask villagers [  ;;针对村民发出指令
    set digital_usage education_villager  ;;设置村民互联网使用水平为教育水平
  ]
end  ;;结束设置“城乡互动”的互联网使用沟

;;设置“城乡互动”的互联网运用能力和智能体知识量（接入和使用综合决定），并针对不同能力的智能体赋予不同外观
to setup_capability_merged  ;;设置“城乡互动”的互联网运用能力和智能体知识量（接入和使用综合决定），并针对不同能力的智能体赋予不同外观
  ;;设置市民知识量
  ask citizens [  ;;针对市民发出指令
    set digital_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.9  ;;设置市民互联网使用能力为互联网接入水平与使用水平共同作用下的线性增长，使用水平影响更大，并赋予城市系数
    set initial_capability digital_capability  ;;将互联网使用能力设置为初始能力
    set current_capability digital_capability  ;;将互联网使用能力设置为当下能力
    set information initial_capability  ;;将初始能力转化为信息量
    set knowledge (information + 0.0001)  ;;设置知识量为信息量的线性增长，赋予初始值以避免为0
  ]

  ;;对市民按知识量排序、分类、设置外观
  let sorted_citizens sort-on [knowledge] citizens  ;;按照市民知识量升序排序
  let citizen_count count citizens ;;统计市民数量
  let top_tier sublist sorted_citizens (citizen_count * 0.7) citizen_count  ;;按照知识量升序排序后，靠后的即为知识量多的智能体。设置高知识量的市民为第70%+1个智能体到最后一个智能体，即后30%（索引为70-99）
  let mid_tier sublist sorted_citizens (citizen_count * 0.3) (citizen_count * 0.7)  ;;设置中知识量的市民为第30%+1个智能体到第70%个智能体，即中间的40%（索引为30-69）
  let low_tier sublist sorted_citizens 0 (citizen_count * 0.3)   ;;设置低知识量的市民为第1个智能体到第30%个智能体，即前30%（索引为0-29）
  ask citizens with [member? self top_tier] [  ;;针对高知识量的市民
    set size 3  ;;尺寸为3
    set color 14  ;;色号为14
  ]
  ask citizens with [member? self mid_tier] [  ;;针对中知识量的市民
    set size 2  ;;尺寸为2
    set color 16  ;;色号为16
  ]
  ask citizens with [member? self low_tier] [  ;;针对低知识量的市民
    set size 1  ;;尺寸为1
    set color 18  ;;色号为18
  ]

  ;;设置村民知识量
  ask villagers [
    set digital_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.7  ;;设置村民互联网使用能力为互联网接入水平与使用水平共同作用下的非线性增长，赋予乡村系数
    set initial_capability digital_capability  ;;将互联网使用能力设置为初始能力
    set current_capability digital_capability  ;;将互联网使用能力设置为当下能力
    set information initial_capability  ;;将初始能力转化为信息量
    set knowledge (information + 0.0001)  ;;设置知识量为信息量的非线性增长，赋予初始值以避免为0
  ]

  ;;对村民按知识量排序、分类、设置外观
  let sorted_villagers sort-on [knowledge] villagers  ;;按照村民知识量升序排序
  let villager_count count villagers  ;;统计村民数量
  let v_top_tier sublist sorted_villagers (villager_count * 0.7) villager_count  ;;按照知识量升序排序后，靠后的即为知识量多的智能体。设置高知识量的村民为第70%+1个智能体到最后一个智能体，即后30%（索引为70-99）
  let v_mid_tier sublist sorted_villagers (villager_count * 0.3) (villager_count * 0.7)  ;;设置中知识量的村民为第30%+1个智能体到第70%个智能体，即中间的40%（索引为30-69）
  let v_low_tier sublist sorted_villagers 0 (villager_count * 0.3)  ;;设置低知识量的村民为第1个智能体到第30%个智能体，即前30%（索引为0-29）
  ask villagers with [member? self v_top_tier] [  ;;针对高知识量的村民
    set size 3  ;;尺寸为3
    set color 104  ;;色号为104
  ]
  ask villagers with [member? self v_mid_tier] [  ;;针对中知识量的村民
    set size 2  ;;尺寸为2
    set color 106  ;;色号为106
  ]
  ask villagers with [member? self v_low_tier] [  ;;针对中知识量的村民
    set size 1  ;;尺寸为1
    set color 108  ;;色号为108
  ]
end  ;;结束设置“城乡互动”的互联网运用能力和智能体知识量

;;============================================================

;;4. 运行主例程
;;设置城乡分离和城乡互动模式下的不同运行逻辑
;;每种模式均包括创造城乡社会网络、智能体移动、更新智能体数字能力、智能体获取信息、转化信息为知识、重置外观
;;城乡互动模式下还包括创造务工人员、乡村精英、城市志愿者，更新三类主体数字能力，三类主体创造自己的社会网络，三类主体为村民提供知识并提升村民数字能力

;;============================================================

;;运行主例程
to go
  if urban_rural_mode = "separated" [  ;;当处于“城乡分离”模式时，执行如下操作
    create_network_separated  ;;创造社会网络（城乡分离）
    move_separated  ;;进行移动（城乡分离）
    update_capability_separated  ;;更新移动后的数字能力（城乡分离）
    gain_information_separated  ;;获取信息（城乡分离）
    convert_knowledge_separated  ;;将信息转化为知识（城乡分离）
    reset_apperance_separated  ;;更新智能体外观（城乡分离）
  ]
  if urban_rural_mode = "merged" [  ;;当处于“城乡互动”模式时，执行如下操作
    create_network_merged  ;;创造社会网络（城乡互动）
    move_merged  ;;进行移动（城乡互动）
    if is_rural_workers? [  ;;当允许出现务工人员时
      create_rural_workers  ;;创造务工人员
      update_worker_capability  ;;更新务工人员数字能力
      worker_donate_information  ;;务工人员提供信息
      worker_gain_information  ;;务工人员获取信息
      worker_cultivate_capability  ;;务工人员提升村民数字能力
    ]
    if is_rural_gentry? [  ;;当允许出现乡村精英时
      create_rural_gentry  ;;创造乡村精英
      update_gentry_capability  ;;更新乡村精英数字能力
      gentry_gain_information  ;;乡村精英获取信息
      gentry_donate_information  ;;乡村精英提供信息
      gentry_cultivate_capability  ;;乡村精英提升村民数字能力
    ]
    if is_urban_volunteers? [  ;;当允许出现城市志愿者时
      create_urban_volunteers  ;;创造城市志愿者
      update_volunteer_capability  ;;更新城市志愿者数字能力
      volunteer_gain_information  ;;城市志愿者获取信息
      volunteer_donate_information  ;;城市志愿者提供信息
      volunteer_cultivate_capability  ;;城市志愿者提升村民数字能力
    ]
    update_capability_merged  ;;更新数字能力（城乡互动）
    gain_information_merged  ;;获取信息（城乡互动）
    convert_knowledge_merged  ;;转化为知识（城乡互动）
    reset_apperance_merged  ;;更新外观（城乡互动）
  ]
  tick  ;;时间推进
end  ;;停止运行主例程

;;创造社会网络（城乡分离）
to create_network_separated  ;;创造社会网络（城乡分离）
  if ticks mod 4 = 0 [  ;;对于城市，每4时间步更新一次社会网络，模拟城乡差异
    create_urban_network_separated  ;;创造城市社会网络（城乡分离）
  ]
  if ticks mod 6 = 0 [  ;;对于乡村，每6时间步更新一次社会网络，模拟城乡差异
    create_rural_network_separated  ;;创造乡村社会网络（城乡分离）
  ]
end  ;;结束创造社会网络（城乡分离）

;;创造城市社会网络（城乡分离）
to create_urban_network_separated  ;;创造城市社会网络（城乡分离）
  ask citizens [  ;;针对市民发出指令
    let max_cap max [initial_capability] of citizens  ;;找到智能体的最大数字能力
    let my_cap initial_capability  ;;设置智能体数字能力为初始数字能力
    let link_vision sqrt (my_cap / max_cap) * 5  ;;通过智能体数字能力与最大数字能力的比值，决定智能体链接视野，通过开方限制视野无限增长，赋予城市系数
    set vision link_vision  ;;设置智能体视野为链接视野
    let connect_probability max (list 1 round ((my_cap / max_cap) * 15))  ;;通过智能体数字能力与最大数字能力的比值，决定智能体创造链接的概率（如果可能性小于1，则取1）
    let urban_neighbours other citizens in-radius link_vision with [not link-neighbor? myself]  ;;让智能体视野范围内没有建立链接的智能体均成为潜在的邻居
    if any? urban_neighbours [  ;;如果存在邻居
      repeat connect_probability [  ;;重复创造链接的概率，即重复多少次
        if any? urban_neighbours [  ;;再次确认存在邻居
          let urban_neighbour one-of urban_neighbours  ;;找出其中的一个邻居
          create-link-with urban_neighbour  ;;智能体与之建立链接
          set urban_neighbours other urban_neighbours with [not link-neighbor? myself]  ;;将其他的没有建立链接的智能体继续设定为邻居
        ]
      ]
    ]
  ]
  ask links [ set color 74 ]  ;;设定链接颜色为74号
end  ;;结束创造城市社会网络（城乡分离）

;;创造乡村社会网络（城乡分离）
to create_rural_network_separated  ;;创造乡村社会网络（城乡分离）
  ask villagers [  ;;针对村民发出指令
    let max_cap max [initial_capability] of villagers  ;;找到智能体的最大数字能力
    let my_cap initial_capability  ;;设置智能体数字能力为初始数字能力
    let link_vision sqrt (my_cap / max_cap) * 3  ;;通过智能体数字能力与最大数字能力的比值，决定智能体链接视野，通过开方限制视野无限增长，赋予乡村系数
    set vision link_vision  ;;设置智能体视野为链接视野
    let connect_probability max (list 1 round ((my_cap / max_cap) * 10))  ;;通过智能体数字能力与最大数字能力的比值，决定智能体创造链接的概率（如果可能性小于1，则取1）
    let rural_neighbours other villagers in-radius link_vision with [not link-neighbor? myself]  ;;让智能体视野范围内没有建立链接的智能体均成为潜在的邻居
    if any? rural_neighbours [  ;;如果存在邻居
      repeat connect_probability [  ;;重复创造链接的概率，即重复多少次
        if any? rural_neighbours [  ;;再次确认存在邻居
          let rural_neighbour one-of rural_neighbours  ;;找出其中的一个邻居
          create-link-with rural_neighbour  ;;智能体与之建立链接
          set rural_neighbours other rural_neighbours with [not link-neighbor? myself]  ;;将其他的没有建立链接的智能体继续设定为邻居
          ]
        ]
      ]
    ]
  ask links [set color 74]  ;;设定链接颜色为74号
end  ;;结束创造乡村社会网络（城乡分离）

;;进行移动（城乡分离）
to move_separated ;;进行移动（城乡分离）
  ask turtles [  ;;针对每一个智能体
    let current_x xcor  ;;设置横坐标为当下的x
    ifelse breed = citizens [  ;;针对种类为市民的智能体
      if ticks mod 40 = 0 [
        if current_x + 1 >= 0 [ ;;针对右侧即城市内部的居民
          rt random 20  ;;向右随机转动[0,20)度
          lt random 20  ;;向左随机转动[0,20)度
          if [pcolor] of patch-ahead 1 = black or xcor + 1 >= max-pxcor [  ;;如果移动的位置面前一片区域为黑色，或者横坐标+1大于坐标最大值
            set heading (heading + 180)  ;;立刻调转方向回到区域内
          ]
        fd 0.5  ;;移动0.5步
        if xcor < 0 [  ;;如果横坐标小于0，即移动到乡村区域
            setxy current_x ycor  ;;将坐标设定为刚才的x和y坐标
          ]
        ]
      ]
    ] [
      if ticks mod 60 = 0 [  ;;针对种类为村民的智能体
        if current_x - 1 < 0 [  ;;针对左侧即乡村内部的居民
          rt random 20  ;;向右随机转动[0,20)度
          lt random 20  ;;向左随机转动[0,20)度
          if [pcolor] of patch-ahead 1 = black or xcor - 1 <= min-pxcor [  ;;如果移动的位置面前一片区域为黑色，或者横坐标-1小于坐标最小值
          set heading (heading + 180)  ;;立刻调转方向回到区域内
          ]
          fd 0.5  ;;移动0.5步
          if xcor >= 0 [  ;;如果横坐标大于等于0，即移动到城市区域
            setxy current_x ycor ;;将坐标设定为刚才的x和y坐标
          ]
        ]
      ]
    ]
    if ycor >= max-pycor or ycor <= min-pycor [ ;;如果纵坐标超出视图
      set heading (- heading)  ;;立刻调转方向回到视图内
    ]
  ]
end  ;;结束进行移动（城乡分离）

;;更新移动后的数字能力（城乡分离）
to update_capability_separated  ;;更新数字能力（城乡分离）
  if ticks mod 4 = 0 [  ;;对于市民，每4时间步更新一次数字能力，模拟城乡差异
    ask citizens [  ;;针对市民发出指令
      set digital_access [station_city] of patch-here   ;;设置市民互联网接入能力为更新后的互联网普及水平
      set current_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.9  ;;设置当下的数字能力为互联网接入水平与使用水平共同作用下的线性增长，使用水平影响更大，赋予城市系数
    ]
  ]
  if ticks mod 6 = 0 [  ;;对于村民，每6时间步更新一次数字能力，模拟城乡差异
    ask villagers [  ;;针对村民发出指令
      set digital_access [station_countryside] of patch-here   ;;设置村民互联网接入能力为更新后的互联网普及水平
      set current_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.7  ;;设置当下的数字能力为互联网接入水平与使用水平共同作用下的线性增长，使用水平影响更大，赋予乡村系数
    ]
  ]
end  ;;结束更新移动后的数字能力（城乡分离）

;;获取信息（城乡分离）
to gain_information_separated  ;;获取信息（城乡分离）
  if ticks mod 4 = 0 [  ;;对于市民，每4时间步获取一次信息，模拟城乡差异
    gain_urban_information_separated  ;;城市获取信息（城乡分离）
  ]
  if ticks mod 6 = 0 [  ;;对于村民，每6时间步获取一次信息，模拟城乡差异
    gain_rural_information_separated  ;;乡村获取信息（城乡分离）
  ]
end  ;;结束获取信息（城乡分离）

;;城市获取信息（城乡分离）
to gain_urban_information_separated  ;;城市获取信息（城乡分离）
  ask citizens [  ;;针对市民发出指令
    let neighbours link-neighbors  ;;让邻居为已经连接的智能体
    if any? neighbours [  ;;如果存在邻居
      let average_information mean [information] of neighbours  ;;取邻居的平均信息量
      let max_information max [information] of neighbours  ;;找出邻居的最大信息量
      if information < average_information [  ;;如果自己的信息量小于平均信息量
        set information information + (average_information - information) * 0.9  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予城市系数
      ]
      if information > average_information and information < max_information [  ;;如果自己的信息量大于平均信息量并小于最大信息量
        set information information + (max_information - information) * 0.9  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予城市系数
      ]
      if information = max_information [  ;;如果自己就是最大信息量
        set information information + (average_information) * 0.9 ;;将自己的信息量更新为原有信息量加上平均信息量（线性增长），赋予城市系数
      ]
    ]
    if not any? neighbours [  ;;如果没有邻居
      set information information + 0.01  ;;将自己的信息量加0.01
    ]
  ]
end  ;;结束城市获取信息（城乡分离）

;;乡村获取信息（城乡分离）
to gain_rural_information_separated  ;;乡村获取信息（城乡分离）
  ask villagers [  ;;针对村民发出指令
    let neighbours link-neighbors  ;;让邻居为已经连接的智能体
    if any? neighbours [  ;;如果存在邻居
      let average_information mean [information] of neighbours  ;;取邻居的平均信息量
      let max_information max [information] of neighbours  ;;找出邻居的最大信息量
      if information < average_information [  ;;如果自己的信息量小于平均信息量
        set information information + (average_information - information) * 0.7  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村系数
      ]
      if information > average_information and information < max_information [  ;;如果自己的信息量大于平均信息量并小于最大信息量
        set information information + (max_information - information) * 0.7  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村系数
      ]
      if information = max_information [  ;;如果自己就是最大信息量
        set information information + (average_information) * 0.7  ;;将自己的信息量更新为原有信息量加上平均信息量（线性增长），赋予乡村系数
      ]
    ]
    if not any? neighbours [  ;;如果没有邻居
      set information information + 0.01  ;;将自己的信息量加0.01
    ]
  ]
end  ;;结束乡村获取信息（城乡分离）

;;将信息转化为知识（城乡分离）
to convert_knowledge_separated  ;;将信息转化为知识（城乡分离）
  if ticks mod 4 = 0 [  ;;对于城市，每4时间步更新一次知识，模拟城乡转化率差异
    convert_urban_knowledge_separated  ;;城市将信息转化为知识（城乡分离）
  ]
  if ticks mod 6 = 0 [  ;;对于乡村，每6时间步更新一次知识，模拟城乡转化率差异
    convert_rural_knowledge_separated  ;;乡村将信息转化为知识（城乡分离）
  ]
end  ;;结束将信息转化为知识（城乡分离）

;;城市将信息转化为知识（城乡分离）
to convert_urban_knowledge_separated  ;;城市将信息转化为知识（城乡分离）
  ask citizens [  ;;针对市民发出指令
    let knowledge_gap information - knowledge  ;;设置知识量差距为现在的信息量与现在的知识量的差值
    if knowledge_gap > 0 [  ;;如果差值大于0，也就是存在还未转化成知识的信息
      set knowledge knowledge + knowledge_gap * 0.9  ;;设置知识量为原有知识量加上赋予城市系数吸收的知识量差距
    ]
  ]
end  ;;结束城市将信息转化为知识（城乡分离）

;;乡村将信息转化为知识（城乡分离）
to convert_rural_knowledge_separated  ;;乡村将信息转化为知识（城乡分离）
  ask villagers [  ;;针对村民发出指令
    let knowledge_gap information - knowledge  ;;设置知识量差距为现在的信息量与现在的知识量的差值
    if knowledge_gap > 0 [  ;;如果差值大于0，也就是存在还未转化成知识的信息
      set knowledge knowledge + knowledge_gap * 0.7  ;;设置知识量为原有知识量加上赋予乡村系数吸收的知识量差距
    ]
  ]
end  ;;结束乡村将信息转化为知识（城乡分离）

;;更新智能体外观（城乡分离）
to reset_apperance_separated  ;;更新智能体外观（城乡分离）
  ;;对市民按知识量排序、分类、设置外观
  let sorted_citizens sort-on [knowledge] citizens  ;;按照市民知识量升序排序
  let citizen_count count citizens ;;统计市民数量
  let top_tier sublist sorted_citizens (citizen_count * 0.7) citizen_count  ;;按照知识量升序排序后，靠后的即为知识量多的智能体。设置高知识量的市民为第70%+1个智能体到最后一个智能体，即后30%（索引为70-99）
  let mid_tier sublist sorted_citizens (citizen_count * 0.3) (citizen_count * 0.7)  ;;设置中知识量的市民为第30%+1个智能体到第70%个智能体，即中间的40%（索引为30-69）
  let low_tier sublist sorted_citizens 0 (citizen_count * 0.3)   ;;设置低知识量的市民为第1个智能体到第30%个智能体，即前30%（索引为0-29）
  ask citizens with [member? self top_tier] [  ;;针对高知识量的市民
    set size 3  ;;尺寸为3
    set color 14  ;;色号为14
  ]
  ask citizens with [member? self mid_tier] [  ;;针对中知识量的市民
    set size 2  ;;尺寸为2
    set color 16  ;;色号为16
  ]
  ask citizens with [member? self low_tier] [  ;;针对低知识量的市民
    set size 1  ;;尺寸为1
    set color 18  ;;色号为18
  ]

  ;;对村民按知识量排序、分类、设置外观
  let sorted_villagers sort-on [knowledge] villagers  ;;按照村民知识量升序排序
  let villager_count count villagers  ;;统计村民数量
  let v_top_tier sublist sorted_villagers (villager_count * 0.7) villager_count  ;;按照知识量升序排序后，靠后的即为知识量多的智能体。设置高知识量的村民为第70%+1个智能体到最后一个智能体，即后30%（索引为70-99）
  let v_mid_tier sublist sorted_villagers (villager_count * 0.3) (villager_count * 0.7)  ;;设置中知识量的村民为第30%+1个智能体到第70%个智能体，即中间的40%（索引为30-69）
  let v_low_tier sublist sorted_villagers 0 (villager_count * 0.3)  ;;设置低知识量的村民为第1个智能体到第30%个智能体，即前30%（索引为0-29）
  ask villagers with [member? self v_top_tier] [  ;;针对高知识量的村民
    set size 3  ;;尺寸为3
    set color 104  ;;色号为104
  ]
  ask villagers with [member? self v_mid_tier] [  ;;针对中知识量的村民
    set size 2  ;;尺寸为2
    set color 106  ;;色号为106
  ]
  ask villagers with [member? self v_low_tier] [  ;;针对中知识量的村民
    set size 1  ;;尺寸为1
    set color 108  ;;色号为108
  ]
end  ;;结束更新智能体外观（城乡分离）

;;创造社会网络（城乡互动）
to create_network_merged  ;;创造社会网络（城乡互动）
  if ticks mod 4 = 0 [  ;;对于城市，每4时间步更新一次社会网络，模拟城乡差异
    create_urban_network_merged  ;;创造城市社会网络（城乡互动）
  ]
  if ticks mod 6 = 0 [  ;;对于乡村，每6时间步更新一次社会网络，模拟城乡差异
    create_rural_network_merged  ;;创造乡村社会网络（城乡互动）
  ]
end  ;;结束创造社会网络（城乡互动）

;;创造城市社会网络（城乡互动）
to create_urban_network_merged ;;创建城市社会网络（城乡互动）
  ask citizens [  ;;针对市民发出指令
    let max_cap max [initial_capability] of citizens  ;;找到智能体的最大数字能力
    let my_cap initial_capability  ;;设置智能体数字能力为初始数字能力
    let link_vision sqrt (my_cap / max_cap) * 5  ;;通过智能体数字能力与最大数字能力的比值，决定智能体链接视野，通过开方限制视野无限增长，赋予城市系数
    set vision link_vision  ;;设置智能体视野为链接视野
    let connect_probability max (list 1 round ((my_cap / max_cap) * 15))  ;;通过智能体数字能力与最大数字能力的比值，决定智能体创造链接的概率（如果可能性小于1，则取1）
    let urban_neighbours other turtles in-radius link_vision with [not link-neighbor? myself]  ;;让智能体视野范围内没有建立链接的智能体均成为潜在的邻居
    if any? urban_neighbours [  ;;如果存在邻居
      repeat connect_probability [  ;;重复创造链接的概率，即重复多少次
        if any? urban_neighbours [  ;;再次确认存在邻居
          let urban_neighbour one-of urban_neighbours  ;;找出其中的一个邻居
          create-link-with urban_neighbour  ;;智能体与之建立链接
          set urban_neighbours other urban_neighbours with [not link-neighbor? myself]  ;;将其他的没有建立链接的智能体继续设定为邻居
        ]
      ]
    ]
  ]
  ask links [ set color 74 ]  ;;设定链接颜色为74号
end  ;;结束创建城市社会网络（城乡互动）

;;创造乡村社会网络（城乡互动）
to create_rural_network_merged  ;;创建乡村社会网络（城乡互动）
  ask villagers [  ;;针对村民发出指令
    let max_cap max [initial_capability] of villagers  ;;找到智能体的最大数字能力
    let my_cap initial_capability  ;;设置智能体数字能力为初始数字能力
    let link_vision sqrt (my_cap / max_cap) * 3  ;;通过智能体数字能力与最大数字能力的比值，决定智能体链接视野，通过开方限制视野无限增长，赋予乡村系数
    set vision link_vision  ;;设置智能体视野为链接视野
    let connect_probability max (list 1 round ((my_cap / max_cap) * 10))  ;;通过智能体数字能力与最大数字能力的比值，决定智能体创造链接的概率（如果可能性小于1，则取1）
    let rural_neighbours other turtles in-radius link_vision with [not link-neighbor? myself]  ;;让智能体视野范围内没有建立链接的智能体均成为潜在的邻居
    if any? rural_neighbours [  ;;如果存在邻居
      repeat connect_probability [  ;;重复创造链接的概率，即重复多少次
        if any? rural_neighbours [  ;;再次确认存在邻居
          let rural_neighbour one-of rural_neighbours  ;;找出其中的一个邻居
          create-link-with rural_neighbour  ;;智能体与之建立链接
          set rural_neighbours other rural_neighbours with [not link-neighbor? myself]  ;;将其他的没有建立链接的智能体继续设定为邻居
        ]
      ]
    ]
  ]
  ask links [ set color 74 ]  ;;设定链接颜色为74号
end  ;;结束创造乡村社会网络（城乡互动）

;;进行移动（城乡互动）
to move_merged  ;;进行移动（城乡互动）
  ask turtles [  ;;针对每一个智能体
    let current_x xcor  ;;设置横坐标为当下的x
    if breed = citizens [  ;;针对种类为市民的智能体
      if ticks mod 40 = 0 [  ;;市民每40时间步移动一次
        if current_x + 1 >= -1 [  ;;针对右侧即城市内部的居民
          rt random 20  ;;向右随机转动[0,20)度
          lt random 20  ;;向左随机转动[0,20)度
          fd 0.5  ;;移动0.5步
          if xcor < -2 [  ;;如果横坐标小于-2，即进入乡村区域
            setxy current_x ycor  ;;将坐标设定为刚才的x和y坐标
          ]
        ]
      ]
    ]
    if breed = rural_gentrys [  ;;针对种类为乡村精英的智能体
      if ticks mod 40 = 0 [  ;;乡村精英每40时间步移动一次
        if current_x + 1 >= -1 [  ;;针对右侧即城市内部的居民
          rt random 20  ;;向右随机转动[0,20)度
          lt random 20  ;;向左随机转动[0,20)度
          fd 0.5  ;;移动0.5步
          if xcor < -2 [  ;;如果横坐标小于-2，即进入乡村区域
            setxy current_x ycor  ;;将坐标设定为刚才的x和y坐标
          ]
        ]
      ]
    ]
    if breed = urban_volunteers [  ;;针对种类为城市志愿者的智能体
      if ticks mod 40 = 0 [  ;;乡村精英每40时间步移动一次
        if current_x - 1 <= 1 [  ;;针对左侧即乡村内部的居民
          rt random 20  ;;向右随机转动[0,20)度
          lt random 20  ;;向左随机转动[0,20)度
          fd 0.5  ;;移动0.5步
          if xcor > 2 [  ;;如果横坐标大于2，即进入城市区域
            setxy current_x ycor  ;;将坐标设定为刚才的x和y坐标
          ]
        ]
      ]
    ]
    if breed = villagers [  ;;针对种类为村民的智能体
      if ticks mod 60 = 0 [  ;;乡村精英每60时间步移动一次
         if current_x - 1 <= 1 [  ;;针对左侧即乡村内部的居民
          rt random 20  ;;向右随机转动[0,20)度
          lt random 20  ;;向左随机转动[0,20)度
          fd 0.5  ;;移动0.5步
          if xcor > 2 [  ;;如果横坐标大于2，即进入城市区域
            setxy current_x ycor  ;;将坐标设定为刚才的x和y坐标
          ]
        ]
      ]
    ]
    if breed = rural_workers [  ;;针对种类为务工人员的智能体
      if ticks mod 60 = 0 [  ;;乡村精英每60时间步移动一次
         if current_x + 1 >= -1 [  ;;针对右侧即城市内部的居民
          rt random 20  ;;向右随机转动[0,20)度
          lt random 20  ;;向左随机转动[0,20)度
          fd 0.5  ;;移动0.5步
          if xcor < -2 [  ;;如果横坐标小于-2，即进入乡村区域
            setxy current_x ycor  ;;将坐标设定为刚才的x和y坐标
          ]
        ]
      ]
    ]
    if ycor >= max-pycor or ycor <= min-pycor [  ;;如果纵坐标超出视图
      set heading (- heading)  ;;立刻调转方向回到视图内
    ]
  ]
end  ;;结束进行移动（城乡互动）

;;创造务工人员
to create_rural_workers  ;;创造务工人员
  if not rural_workers_created? [  ;;当未创造务工人员时
    ;;选择务工人员来源
    let worker_count number_of_workers  ;;让务工人员数量为界面设定好的数量
    let sorted_workers sort-on [digital_capability] villagers  ;;依据数字能力将村民升序排列，设定为已排列的工人
    let total_workers length sorted_workers  ;;让总的工人数量（村民数量）为已排列的工人长度
    let middle_index floor (total_workers / 2) - floor (worker_count / 2)  ;;让选取的工人索引起点为总的村民数量的一半减去应创造的工人数量的一半

    ;;确保索引起点在有效范围内，然后选择中间位置的worker_count个workers
    if middle_index < 0 [  ;;如果索引起点小于0，也就是总的村民数量少于应创造的工人数量
      set middle_index 0  ;;让索引起点为0
    ]  ;;
    if middle_index + worker_count > total_workers [  ;;如果索引起点加上应创造的工人数量大于总的村民数量
      set middle_index total_workers - worker_count  ;;让索引起点为总的村民数量减去应创造的工人数量
    ]

    ;;将村民转化为务工人员
    let potential_workers turtle-set sublist sorted_workers middle_index (middle_index + worker_count)  ;;让潜在的务工人员为从索引起点到索引起点加上应创造的工人数量的村民
    ask potential_workers [  ;;针对潜在的务工人员
      set breed rural_workers  ;;设置种类为务工人员
      let x 5 + random-float 85  ;;设置横坐标为[5,90)
      let y -47 + random-float 93  ;;设置纵坐标为[-47,46)
      setxy x y  ;;设置横纵坐标
      set color blue  ;;设置颜色为blue
      set size 4  ;;设置尺寸为4
      set shape "person"  ;;设置形状为“person”
    ]
    set rural_workers_created? true  ;;设置已创造务工人员，即保证只创造一次
  ]
end  ;;结束创造务工人员

;;更新务工人员数字能力
to update_worker_capability  ;;更新务工人员数字能力
  if ticks mod 6 = 0 [  ;;对于务工人员，每6时间步获取一次信息，模拟城乡差异
    ask rural_workers [  ;;针对务工人员发出指令
      set digital_access [station_city] of patch-here  ;;设置互联网接入水平为区域互联网普及水平
      set current_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.7  ;;设置现在的数字能力为互联网接入水平与使用水平共同作用下的线性增长，赋予村民系数
    ]
  ]
end  ;;结束更新务工人员数字能力

;;务工人员提供信息
to worker_donate_information  ;;务工人员提供信息
  ;;建立务工人员社会网络
  if ticks mod 6 = 0 [  ;;对于务工人员，每6时间步更新一次社会网络
    if any? villagers [  ;;确认存在村民
      ask rural_workers [  ;;针对务工人员发出指令
        if initial_capability = 0 [set initial_capability 0.001]  ;;如果务工人员的初始能力为0，则赋予初始能力一个小值
        let max_cap max [initial_capability] of villagers  ;;找到智能体的最大数字能力
        let my_cap initial_capability  ;;设置智能体数字能力为初始数字能力
        let link_vision sqrt my_cap * 8  ;;通过智能体数字能力与最大数字能力的比值，决定智能体链接视野，赋予乡村系数
        set vision link_vision  ;;设置智能体视野为链接视野
        let connect_probability max (list 1 round (my_cap / max_cap * 12))  ;;通过智能体数字能力与最大数字能力的比值，决定智能体创造链接的概率（如果可能性小于1，则取1）
        let rural_neighbours other turtles in-radius link_vision with [not link-neighbor? myself]  ;;让智能体视野范围内没有建立链接的智能体均成为潜在的邻居
        if any? rural_neighbours [  ;;如果存在邻居
          repeat connect_probability [  ;;重复创造链接的概率，即重复多少次
            if any? rural_neighbours [  ;;再次确认存在邻居
              let rural_neighbour one-of rural_neighbours  ;;找出其中的一个邻居
              create-link-with rural_neighbour  ;;智能体与之建立链接
              set rural_neighbours other rural_neighbours with [not link-neighbor? myself]  ;;将其他的没有建立链接的智能体继续设定为邻居
            ]
          ]
        ]
      ]
    ]
  ]
  ask links [ set color 74 ]  ;;设定链接颜色为74号

  ;;村民获取务工人员提供的信息
  if ticks mod 6 = 0 [  ;;对于村民，每6时间步获取一次信息
    ask villagers [  ;;针对村民发出指令
      let worker_neighbours link-neighbors with [breed = rural_workers]  ;;让与自己链接的务工人员为务工人员邻居
      if any? worker_neighbours [  ;;如果存在务工人员邻居
        let worker_avg_info mean [information] of worker_neighbours  ;;取邻居的平均信息量
        ifelse worker_avg_info > information [  ;;如果自己的信息量小于平均信息量
          let info_gain (worker_avg_info - information) * 0.009 ;;设置应该获取的信息为平均信息量与自己的信息量的差值，赋予务工人员系数
          set information information + info_gain  ;;将自己的信息量更新为原有信息量加上应该获取的信息量
        ][
          let info_gain (information - worker_avg_info) * 0.005  ;;如果自己的信息量大于平均信息量，则将自己的信息量与平均知识量的差值设定为应该获取的信息量
          set information information + info_gain  ;;将自己的信息量更新为原有信息量加上应该获取的信息量
        ]
      ]
    ]
  ]
end  ;;结束务工人员提供信息

;;务工人员获取信息
to worker_gain_information  ;;务工人员获取信息
  if ticks mod 6 = 0 [  ;;对于务工人员，每6时间步获取一次信息
    ask rural_workers [  ;;针对务工人员发出指令
      let neighbours link-neighbors  ;;让邻居为已经连接的智能体
      if any? neighbours [  ;;如果存在邻居
        let average_information mean [information] of neighbours  ;;取邻居的平均信息量
        let max_information max [information] of neighbours  ;;找出邻居的最大信息量
        if information < average_information [  ;;如果自己的信息量小于平均信息量
          set information information + (average_information - information) * 0.7  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村系数
        ]
        if information > average_information and information < max_information [  ;;如果自己的信息量大于平均信息量并小于最大信息量
          set information information + (max_information - information) * 0.7  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村系数
        ]
        if information = max_information [  ;;如果自己就是最大信息量
          set information information + (average_information) * 0.7  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村系数
        ]
      ]
      if not any? neighbours [  ;;如果没有邻居
        set information information + 0.01  ;;将自己的信息量加0.01
      ]
    ]
  ]
end  ;;结束务工人员获取信息

;;务工人员提升村民数字能力
to worker_cultivate_capability  ;;务工人员提升村民数字能力
  if ticks mod 6 = 0 [ ;;对于村民，每6时间步提升一次数字能力
    ask villagers [  ;;针对村民发出指令
      let worker_neighbours link-neighbors with [breed = rural_workers]  ;;让与自己链接的务工人员为务工人员邻居
      if any? worker_neighbours [  ;;如果存在务工人员邻居
        let worker_avg_cap mean [current_capability] of worker_neighbours  ;;取邻居的平均数字能力
        ifelse worker_avg_cap > current_capability [  ;;如果自己的数字能力小于平均数字能力
          let cap_gain (worker_avg_cap - current_capability) * 0.009  ;;将应该增加的数字能力设定为平均数字能力与自己的数字能力的差值，赋予务工人员系数
          set current_capability current_capability + cap_gain  ;;将自己的数字能力更新为原有数字能力加上应该获取的数字能力
        ][
          let cap_gain (worker_avg_cap - current_capability) * 0.005  ;;如果自己的数字能力大于平均数字能力，将应该增加的数字能力设定为自己的数字能力与平均数字能力的差值，赋予务工人员系数
          set current_capability current_capability + cap_gain  ;;将自己的数字能力更新为原有数字能力加上应该获取的数字能力
        ]
      ]
    ]
  ]
end  ;;结束务工人员提升村民数字能力

;;创造乡村精英
to create_rural_gentry  ;;创造乡村精英
  if not rural_gentry_created? [  ;;当未创造乡村精英时
    ;;选择乡村精英来源
    let elite_count number_of_gentrys  ;;让乡村精英数量为界面设定好的数量
    let potential_gentry max-n-of elite_count villagers [digital_capability]  ;;让潜在的乡村精英为所有村民中数字能力最高的设定好的数量个的村民

    ;;将村民转化为乡村精英
    ask potential_gentry [  ;;针对潜在的乡村精英发出指令
      ;;存储原有属性
      let temp_edu education_villager  ;;设定原有的村民教育水平为中间量
      let temp_cap digital_capability  ;;设定原有的村民数字能力为中间量
      let temp_info information  ;;设定原有的信息为中间量

      ;;设置外观和位置
      set breed rural_gentrys  ;;设定种类为乡村精英
      set color blue  ;;设定颜色为blue
      set size 4  ;;设定尺寸为4
      set shape "person"  ;;设定形状为“person”
      let x 5 + random-float 85  ;;设置横坐标为[5,90)
      let y -47 + random-float 93  ;;设置纵坐标为[-47,46)
      setxy x y  ;;设置横纵坐标

      ; 恢复原有属性
      set education_villager temp_edu  ;;将中间量转为现在的教育水平，因为教育水平为所有智能体共有的属性
      set digital_capability temp_cap  ;;将中间量转为现在的数字能力
      set information temp_info  ;;将中间量转为现在的信息量
    ]
    set rural_gentry_created? true  ;;设置已创造乡村精英，即保证只创造一次
  ]
end  ;;结束创造乡村精英

;;更新乡村精英数字能力
to update_gentry_capability  ;;更新乡村精英数字能力
  if ticks mod 4 = 0 [  ;;对于乡村精英，每4时间步更新一次数字能力
    ask rural_gentrys [  ;;针对乡村精英发出指令
      set digital_access [station_city] of patch-here  ;;设置互联网接入水平为区域互联网普及水平
      set current_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.9  ;;设置现在的数字能力为互联网接入水平与使用水平共同作用下的线性增长，赋予城市系数
    ]
  ]
end  ;;结束更新乡村精英数字能力

;;乡村精英获取信息
to gentry_gain_information  ;;乡村精英获取信息
  ;;建立乡村精英社会网络
  if ticks mod 4 = 0 [  ;;对于乡村精英，每4时间步更新一次社会网络
    ask rural_gentrys [  ;;针对乡村精英发出指令
      if initial_capability = 0 [set initial_capability 0.001]  ;;如果乡村精英的初始能力为0，则赋予初始能力一个小值
      let max_cap max [initial_capability] of citizens  ;;找到智能体的最大数字能力
      let my_cap initial_capability  ;;设置智能体数字能力为初始数字能力
      let link_vision sqrt (my_cap / max_cap) * 6  ;;通过智能体数字能力与最大数字能力的比值，决定智能体链接视野，赋予乡村精英系数
      set vision link_vision  ;;设置智能体视野为链接视野
      let connect_probability max (list 1 round ((my_cap / max_cap) * 15))  ;;通过智能体数字能力与最大数字能力的比值，决定智能体创造链接的概率（如果可能性小于1，则取1）
      let urban_neighbours other turtles in-radius link_vision with [not link-neighbor? myself and count my-links < 10]  ;;让智能体视野范围内没有建立链接的智能体均成为潜在的邻居
      if any? urban_neighbours [  ;;如果存在邻居
        repeat connect_probability [  ;;重复创造链接的概率，即重复多少次
          if any? urban_neighbours [  ;;再次确认存在邻居
            let urban_neighbour one-of urban_neighbours  ;;找出其中的一个邻居
            create-link-with urban_neighbour  ;;智能体与之建立链接
            set urban_neighbours other urban_neighbours with [not link-neighbor? myself]  ;;将其他的没有建立链接的智能体继续设定为邻居
          ]
        ]
      ]
    ]
  ]
  ask links [ set color 74]  ;;设定链接颜色为74号

  ;;乡村精英获取信息
  if ticks mod 4 = 0 [  ;;对于乡村精英，每4时间步获取一次信息
    ask rural_gentrys [  ;;针对乡村精英发出指令
      let neighbours link-neighbors  ;;让邻居为已经连接的智能体
      if any? neighbours [  ;;如果存在邻居
        let average_information mean [information] of neighbours  ;;取邻居的平均信息量
        let max_information max [information] of neighbours  ;;找出邻居的最大信息量
        if information < average_information [  ;;如果自己的信息量小于平均信息量
          set information information + (average_information - information) * 0.9  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村精英系数
        ]
        if information > average_information and information < max_information [  ;;如果自己的信息量大于平均信息量并小于最大信息量
          set information information + (max_information - information) * 0.9  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村精英系数
        ]
        if information = max_information [  ;;如果自己就是最大信息量
          set information information + (average_information) * 0.9  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村精英系数
        ]
      ]
      if not any? neighbours [  ;;如果没有邻居
        set information information + 0.01  ;;将自己的信息量加0.01
      ]
    ]
  ]
end  ;;乡村精英获取信息

;;乡村精英提供信息
to gentry_donate_information  ;;乡村精英提供信息
  ;;建立乡村精英与村民的链接
  if not gentry_link_created? [  ;;当还未创造乡村精英与村民的链接时
    ask rural_gentrys [  ;;针对乡村精英发出指令
      let unlinked_villagers villagers with [not link-neighbor? myself]  ;;设定还没有与自己链接的村民为还未链接村民
      let link_count min (list 4 count unlinked_villagers)  ;;设定链接数量为4和还未连接村民数量之间最小值，即保证至少为4
      let target_villagers n-of link_count unlinked_villagers  ;;让目标村民为从还未链接村民中链接数量个村民
      ask target_villagers [  ;;针对目标村民
        create-link-with myself [  ;;与自己建立链接
          ask links [  ;;针对链接
            set color white  ;;设定颜色为白色
            set thickness 0.2  ;;设定宽度为0.2
          ]
        ]
      ]
    ]
    set gentry_link_created? true  ;;设置已创造乡村精英与村民的链接，即保证只创造一次
  ]

  ;;村民从乡村精英获取信息
  if ticks mod 6 = 0 [  ;;对于村民，每6时间步获取一次信息
    ask villagers [  ;;针对村民
      let gentry_neighbours link-neighbors with [breed = rural_gentrys]  ;;设定精英邻居为与自己链接的乡村精英
      if any? gentry_neighbours [  ;;如果存在精英邻居
        let gentry_avg_info mean [information] of gentry_neighbours  ;;取邻居的平均信息量
        ifelse gentry_avg_info > information [  ;;如果自己的信息量小于平均信息量
          let info_gain (gentry_avg_info - information) * 0.02  ;;设定应获取的信息量为平均信息量与自己的信息量的差值，赋予乡村精英系数
          set information information + info_gain  ;;设定现在的信息量为原有信息量加上应获取的信息量
        ][
          let info_gain (information - gentry_avg_info) * 0.01  ;;如果自己的信息量大于平均信息量，设定应获取的信息量为自己的信息量与平均信息量差值，赋予乡村精英系数
          set information information + info_gain  ;;设定现在的信息量为原有信息量加上应获取的信息量
        ]
      ]
    ]
  ]
end  ;;结束乡村精英提供信息

;;乡村精英提升村民数字能力
to gentry_cultivate_capability  ;;乡村精英提升村民数字能力
  if ticks mod 6 = 0 [  ;;对于村民，每6时间步提升一次数字能力
    ask villagers [  ;;针对村民发出指令
      let gentry_neighbours link-neighbors with [breed = rural_gentrys]  ;;让与自己链接的乡村精英为精英邻居
      if any? gentry_neighbours [  ;;如果存在精英邻居
        let gentry_avg_cap mean [current_capability] of gentry_neighbours  ;;取邻居的平均数字能力
        ifelse gentry_avg_cap > current_capability [  ;;如果自己的数字能力小于平均数字能力
          let cap_gain (gentry_avg_cap - current_capability) * 0.02  ;;将应该增加的数字能力设定为平均数字能力与自己的数字能力的差值，赋予乡村精英系数
          set current_capability current_capability + cap_gain  ;;将自己的数字能力更新为原有数字能力加上应该获取的数字能力
        ][
          let cap_gain (gentry_avg_cap - current_capability) * 0.01   ;;如果自己的数字能力大于平均数字能力，将应该增加的数字能力设定为自己的数字能力与平均数字能力的差值，赋予乡村精英系数
          set current_capability current_capability + cap_gain  ;;将自己的数字能力更新为原有数字能力加上应该获取的数字能力
        ]
      ]
    ]
  ]
end  ;;结束乡村精英提升村民数字能力

;;创造城市志愿者
to create_urban_volunteers  ;;创造城市志愿者
  if not urban_volunteers_created? [  ;;当未创造城市志愿者时
                                      ;;选择城市志愿者来源
    let elite_count number_of_volunteers  ;;让城市志愿者数量为界面设定好的数量
    let potential_volunteers max-n-of elite_count citizens [digital_capability]  ;;让潜在的城市志愿者为所有市民中数字能力最高的设定好的数量个的村民

    ;;将市民转化为城市志愿者
    ask potential_volunteers [  ;;针对潜在的城市志愿者发出指令
      let temp_edu education_citizen  ;;设定原有的市民教育水平为中间量
      let temp_cap digital_capability  ;;设定原有的市民数字能力为中间量
      let temp_info information  ;;设定原有的信息为中间量

      ;;设置外观和位置
      set breed urban_volunteers  ;;设定种类为城市志愿者
      set color red  ;;设定颜色为red
      set size 4  ;;设定尺寸为4
      set shape "person"  ;;设定形状为“person”
      let x -5 + random-float -85  ;;设置横坐标为[5,90)
      let y -47 + random-float 93  ;;设置纵坐标为[-47,46)
      setxy x y  ;;设置横纵坐标

      ; 恢复原有属性
      set education_citizen temp_edu  ;;将中间量转为现在的教育水平，因为教育水平为所有智能体共有的属性
      set digital_capability temp_cap  ;;将中间量转为现在的数字能力
      set information temp_info  ;;将中间量转为现在的信息量
    ]
    set urban_volunteers_created? true  ;;设置已创造城市志愿者，保证只创造一次
  ]
end  ;;结束创造城市志愿者

;;更新城市志愿者数字能力
to update_volunteer_capability  ;;更新城市志愿者数字能力
  if ticks mod 4 = 0 [  ;;对于城市志愿者，每4时间步更新一次数字能力
    ask urban_volunteers [  ;;针对城市志愿者发出指令
      set digital_access [station_countryside] of patch-here  ;;设置互联网接入水平为区域互联网普及水平
      set current_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.9  ;;设置现在的数字能力为互联网接入水平与使用水平共同作用下的线性增长，赋予城市系数
    ]
  ]
end  ;;结束更新城市志愿者数字能力

;;城市志愿者获取信息
to volunteer_gain_information  ;;城市志愿者获取信息
  ;;建立城市志愿者社会网络
  if ticks mod 4 = 0 [  ;;对于城市志愿者，每4时间步更新一次社会网络
  ask urban_volunteers [  ;;针对城市志愿者发出指令
      if current_capability = 0 [set current_capability 0.001]  ;;如果城市志愿者的初始能力为0，则赋予初始能力一个小值
      let max_cap max [current_capability] of villagers    ;;找到智能体的最大数字能力
      let my_cap current_capability  ;;设置智能体数字能力为初始数字能力
      let link_vision sqrt (my_cap / max_cap) * 6  ;;通过智能体数字能力与最大数字能力的比值，决定智能体链接视野，赋予城市志愿者系数
      set vision link_vision  ;;设置智能体视野为链接视野
      let connect_probability max (list 1 round ((my_cap / max_cap) * 12))  ;;通过智能体数字能力与最大数字能力的比值，决定智能体创造链接的概率（如果可能性小于1，则取1）
      let rural_neighbours other turtles in-radius link_vision with [not link-neighbor? myself and count my-links < 10]  ;;让智能体视野范围内没有建立链接的智能体均成为潜在的邻居
      if any? rural_neighbours [  ;;如果存在邻居
        repeat connect_probability [  ;;重复创造链接的概率，即重复多少次
          if any? rural_neighbours [  ;;再次确认存在邻居
            let rural_neighbour one-of rural_neighbours  ;;找出其中的一个邻居
            create-link-with rural_neighbour  ;;智能体与之建立链接
            set rural_neighbours other rural_neighbours with [not link-neighbor? myself]  ;;将其他的没有建立链接的智能体继续设定为邻居
          ]
        ]
      ]
    ]
  ]
  ask links [ set color 74 ]  ;;设定链接颜色为74号

  ;;城市志愿者获取信息
  if ticks mod 4 = 0 [  ;;对于城市志愿者，每4时间步获取一次信息
    ask urban_volunteers [  ;;针对城市志愿者发出指令
      let neighbours link-neighbors  ;;让邻居为已经连接的智能体
      if any? neighbours [  ;;如果存在邻居
        let average_information mean [information] of neighbours  ;;取邻居的平均信息量
        let max_information max [information] of neighbours  ;;找出邻居的最大信息量
        if information < average_information [  ;;如果自己的信息量小于平均信息量
          set information information + (average_information - information) * 0.9  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予城市志愿者系数
        ]
        if information > average_information and information < max_information [  ;;如果自己的信息量大于平均信息量并小于最大信息量
          set information information + (max_information - information) * 0.9  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予城市志愿者系数
        ]
        if information = max_information [  ;;如果自己就是最大信息量
          set information information + (average_information) * 0.9  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予城市志愿者系数
        ]
      ]
      if not any? neighbours [  ;;如果没有邻居
        set information information + 0.01  ;;将自己的信息量加0.01
      ]
    ]
  ]
end  ;;结束城市志愿者获取信息

;;城市志愿者提供信息
to volunteer_donate_information  ;;城市志愿者提供信息
  ;;建立城市志愿者与村民的链接
  if not volunteer_link_created? [  ;;当还未创造城市志愿者与村民的链接时
    ask urban_volunteers [  ;;针对城市志愿者发出指令
      let unlinked_villagers villagers with [not link-neighbor? myself]  ;;设定还没有与自己链接的村民为还未链接村民
      let link_count min (list 4 count unlinked_villagers)  ;;设定链接数量为4和还未连接村民数量之间最小值，即保证至少为4
      let target_villagers n-of link_count unlinked_villagers  ;;让目标村民为从还未链接村民中链接数量个村民
      ask target_villagers [  ;;针对目标村民
        create-link-with myself [  ;;与自己建立链接
          ask links [  ;;针对链接
            set color white  ;;设定颜色为白色
            set thickness 0.2  ;;设定宽度为0.2
          ]
        ]
      ]
    ]
    set volunteer_link_created? true  ;;设置已创造乡村精英与村民的链接，即保证只创造一次
  ]

  ;;村民从城市志愿者获取信息
  if ticks mod 6 = 0 [  ;;对于村民，每6时间步获取一次信息
    ask villagers [  ;;针对村民
      let volunteer_neighbours link-neighbors with [breed = urban_volunteers]  ;;设定志愿者邻居为与自己链接的城市志愿者
      if any? volunteer_neighbours [  ;;如果存在志愿者邻居
        let volunteer_avg_info mean [information] of volunteer_neighbours  ;;取邻居的平均信息量
        ifelse volunteer_avg_info > information [  ;;如果自己的信息量小于平均信息量
          let info_gain (volunteer_avg_info - information) * 0.02  ;;设定应获取的信息量为平均信息量与自己的信息量的差值，赋予城市志愿者系数
          set information information + info_gain  ;;设定现在的信息量为原有信息量加上应获取的信息量
        ][
          let info_gain (information - volunteer_avg_info) * 0.01  ;;如果自己的信息量大于平均信息量，设定应获取的信息量为自己的信息量与平均信息量差值，赋予城市志愿者系数
          set information information + info_gain  ;;设定现在的信息量为原有信息量加上应获取的信息量
        ]
      ]
    ]
  ]
end  ;;结束城市志愿者提供信息

;;城市志愿者提升村民数字能力
to volunteer_cultivate_capability  ;;城市志愿者提升村民数字能力
  if ticks mod 6 = 0 [  ;;对于村民，每6时间步提升一次数字能力
    ask villagers [  ;;针对村民发出指令
      let volunteer_neighbours link-neighbors with [breed = urban_volunteers]  ;;让与自己链接的城市志愿者为志愿者邻居
      if any? volunteer_neighbours [  ;;如果存在志愿者邻居
        let volunteer_avg_cap mean [current_capability] of volunteer_neighbours  ;;取邻居的平均数字能力
        ifelse volunteer_avg_cap > current_capability [  ;;如果自己的数字能力小于平均数字能力
          let cap_gain (volunteer_avg_cap - current_capability) * 0.02  ;;将应该增加的数字能力设定为平均数字能力与自己的数字能力的差值，赋予志愿者系数
          set current_capability current_capability + cap_gain  ;;将自己的数字能力更新为原有数字能力加上应该获取的数字能力
        ][
          let cap_gain (volunteer_avg_cap - current_capability) * 0.01  ;;如果自己的数字能力大于平均数字能力，将应该增加的数字能力设定为自己的数字能力与平均数字能力的差值，赋予志愿者系数
          set current_capability current_capability + cap_gain  ;;将自己的数字能力更新为原有数字能力加上应该获取的数字能力
        ]
      ]
    ]
  ]
end  ;;结束城市志愿者提升村民数字能力

;;更新移动后的数字能力（城乡互动）
to update_capability_merged  ;;更新移动后的数字能力（城乡互动）
  if ticks mod 4 = 0 [  ;;对于市民，每4时间步更新一次数字能力，模拟城乡差异
    ask citizens [  ;;针对市民发出指令
      set digital_access [station_city] of patch-here  ;;设置市民互联网接入能力为更新后的互联网普及水平
      set current_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.9  ;;设置当下的数字能力为互联网接入水平与使用水平共同作用下的线性增长，使用水平影响更大，赋予城市系数
    ]
  ]
  if ticks mod 6 = 0 [  ;;对于村民，每6时间步更新一次数字能力，模拟城乡差异
    ask villagers [  ;;针对村民发出指令
      set digital_access [station_countryside] of patch-here  ;;设置村民互联网接入能力为更新后的互联网普及水平
      set current_capability (digital_access * 0.4 + digital_usage * 0.6) * 0.7  ;;设置当下的数字能力为互联网接入水平与使用水平共同作用下的线性增长，使用水平影响更大，赋予乡村系数
    ]
  ]
end  ;;结束更新移动后的数字能力（城乡互动）

;;获取信息（城乡互动）
to gain_information_merged  ;;获取信息（城乡互动）
  if ticks mod 4 = 0 [  ;;对于市民，每4时间步获取一次信息，模拟城乡差异
    gain_urban_information_merged  ;;城市获取信息（城乡互动）
  ]
  if ticks mod 6 = 0 [  ;;对于村民，每6时间步获取一次信息，模拟城乡差异
    gain_rural_information_merged  ;;乡村获取信息（城乡互动）
  ]
end  ;;结束获取信息（城乡互动）

;;城市获取信息（城乡互动）
to gain_urban_information_merged  ;;城市获取信息（城乡互动）
  ask citizens [  ;;针对市民发出指令
    let neighbours link-neighbors  ;;让邻居为已经连接的智能体
    if any? neighbours [  ;;如果存在邻居
      let average_information mean [information] of neighbours  ;;取邻居的平均信息量
      let max_information max [information] of neighbours  ;;找出邻居的最大信息量
      if information < average_information [  ;;如果自己的信息量小于平均信息量
        set information information + (average_information - information) * 0.9 ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予城市系数
      ]
      if information > average_information and information < max_information [  ;;如果自己的信息量大于平均信息量并小于最大信息量
        set information information + (max_information - information) * 0.9  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予城市系数
      ]
      if information = max_information [  ;;如果自己就是最大信息量
        set information information + (average_information) * 0.9  ;;将自己的信息量更新为原有信息量加上平均信息量（线性增长），赋予城市系数
      ]
    ]
    if not any? neighbours [  ;;如果没有邻居
      set information information + 0.01  ;;将自己的信息量加0.01
    ]
  ]
end  ;;结束城市获取信息（城乡互动）

;;乡村获取信息（城乡互动）
to gain_rural_information_merged  ;;乡村获取信息（城乡互动）
  ask villagers [  ;;针对村民发出指令
    let neighbours link-neighbors  ;;让邻居为已经连接的智能体
    if any? neighbours [  ;;如果存在邻居
      let average_information mean [information] of neighbours  ;;取邻居的平均信息量
      let max_information max [information] of neighbours  ;;找出邻居的最大信息量
      if information < average_information [  ;;如果自己的信息量小于平均信息量
        set information information + (average_information - information) * 0.7  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村系数
      ]
      if information > average_information and information < max_information [  ;;如果自己的信息量大于平均信息量并小于最大信息量
        set information information + (max_information - information) * 0.7  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村系数
      ]
      if information = max_information [  ;;如果自己就是最大信息量
        set information information + (average_information) * 0.7  ;;将自己的信息量更新为原有信息量加上最大信息量与自己的信息量差值（线性增长），赋予乡村系数
      ]
    ]
    if not any? neighbours [  ;;如果没有邻居
      set information information + 0.01  ;;将自己的信息量加0.01
    ]
  ]
end  ;;结束乡村获取信息（城乡互动）

;;转化为知识（城乡互动）
to convert_knowledge_merged  ;;转化为知识（城乡互动）
  convert_urban_knowledge_merged  ;;城市转化知识（城乡互动）
  convert_rural_knowledge_merged  ;;乡村转化知识（城乡互动）
end  ;;结束转化为知识（城乡互动）

;;城市转化知识（城乡互动）
to convert_urban_knowledge_merged  ;;城市转化知识（城乡互动）
  if ticks mod 4 = 0 [  ;;对于市民、城市志愿者、乡村精英，每4时间步转化一次知识，体现城乡差异
    ask citizens [  ;;针对市民
      let knowledge_gap information - knowledge  ;;设置知识量差距为现在的信息量与现在的知识量的差值
      if knowledge_gap > 0 [  ;;如果差值大于0，也就是存在还未转化成知识的信息
        set knowledge knowledge + knowledge_gap * 0.9  ;;设置知识量为原有知识量加上赋予城市系数吸收的知识量差距
      ]
    ]
    ask urban_volunteers [  ;;针对城市志愿者
      let knowledge_gap information - knowledge  ;;设置知识量差距为现在的信息量与现在的知识量的差值
      if knowledge_gap > 0 [  ;;如果差值大于0，也就是存在还未转化成知识的信息
        set knowledge knowledge + knowledge_gap * 0.9  ;;设置知识量为原有知识量加上赋予城市系数吸收的知识量差距
      ]
    ]
    ask rural_gentrys [  ;;针对乡村精英
      let knowledge_gap information - knowledge  ;;设置知识量差距为现在的信息量与现在的知识量的差值
      if knowledge_gap > 0 [  ;;如果差值大于0，也就是存在还未转化成知识的信息
        set knowledge knowledge + knowledge_gap * 0.9  ;;设置知识量为原有知识量加上赋予城市系数吸收的知识量差距
      ]
    ]
  ]
end  ;;结束城市转化知识（城乡互动）

;;乡村转化知识（城乡互动）
to convert_rural_knowledge_merged  ;;乡村转化知识（城乡互动）
  if ticks mod 6 = 0 [  ;;对于村民、务工人员，每6时间步转化一次知识，体现城乡差异
    ask villagers [  ;;针对村民
      let knowledge_gap information - knowledge  ;;设置知识量差距为现在的信息量与现在的知识量的差值
      if knowledge_gap > 0 [  ;;如果差值大于0，也就是存在还未转化成知识的信息
        set knowledge knowledge + knowledge_gap * 0.7  ;;设置知识量为原有知识量加上赋予乡村系数吸收的知识量差距
      ]
    ]
    ask rural_workers [  ;;针对务工人员
      let knowledge_gap information - knowledge  ;;设置知识量差距为现在的信息量与现在的知识量的差值
      if knowledge_gap > 0 [  ;;如果差值大于0，也就是存在还未转化成知识的信息
        set knowledge knowledge + knowledge_gap * 0.7  ;;设置知识量为原有知识量加上赋予乡村系数吸收的知识量差距
      ]
    ]
  ]
end  ;;结束乡村转化知识（城乡互动）

;;更新智能体外观（城乡互动）
to reset_apperance_merged  ;;更新智能体外观（城乡互动）
  ;;对市民按知识量排序、分类、设置外观
  let sorted_citizens sort-on [knowledge] citizens  ;;按照市民知识量升序排序
  let citizen_count count citizens ;;统计市民数量
  let top_tier sublist sorted_citizens (citizen_count * 0.7) citizen_count  ;;按照知识量升序排序后，靠后的即为知识量多的智能体。设置高知识量的市民为第70%+1个智能体到最后一个智能体，即后30%（索引为70-99）
  let mid_tier sublist sorted_citizens (citizen_count * 0.3) (citizen_count * 0.7)  ;;设置中知识量的市民为第30%+1个智能体到第70%个智能体，即中间的40%（索引为30-69）
  let low_tier sublist sorted_citizens 0 (citizen_count * 0.3)   ;;设置低知识量的市民为第1个智能体到第30%个智能体，即前30%（索引为0-29）
  ask citizens with [member? self top_tier] [  ;;针对高知识量的市民
    set size 3  ;;尺寸为3
    set color 14  ;;色号为14
  ]
  ask citizens with [member? self mid_tier] [  ;;针对中知识量的市民
    set size 2  ;;尺寸为2
    set color 16  ;;色号为16
  ]
  ask citizens with [member? self low_tier] [  ;;针对低知识量的市民
    set size 1  ;;尺寸为1
    set color 18  ;;色号为18
  ]

  ;;对村民按知识量排序、分类、设置外观
  let sorted_villagers sort-on [knowledge] villagers  ;;按照村民知识量升序排序
  let villager_count count villagers  ;;统计村民数量
  let v_top_tier sublist sorted_villagers (villager_count * 0.7) villager_count  ;;按照知识量升序排序后，靠后的即为知识量多的智能体。设置高知识量的村民为第70%+1个智能体到最后一个智能体，即后30%（索引为70-99）
  let v_mid_tier sublist sorted_villagers (villager_count * 0.3) (villager_count * 0.7)  ;;设置中知识量的村民为第30%+1个智能体到第70%个智能体，即中间的40%（索引为30-69）
  let v_low_tier sublist sorted_villagers 0 (villager_count * 0.3)  ;;设置低知识量的村民为第1个智能体到第30%个智能体，即前30%（索引为0-29）
  ask villagers with [member? self v_top_tier] [  ;;针对高知识量的村民
    set size 3  ;;尺寸为3
    set color 104  ;;色号为104
  ]
  ask villagers with [member? self v_mid_tier] [  ;;针对中知识量的村民
    set size 2  ;;尺寸为2
    set color 106  ;;色号为106
  ]
  ask villagers with [member? self v_low_tier] [  ;;针对中知识量的村民
    set size 1  ;;尺寸为1
    set color 108  ;;色号为108
  ]
end  ;;结束更新智能体外观（城乡互动）

;;==============================================

;;5. 汇报关键信息

;;汇报初始城市平均知识量
to-report initial_ave_u_knowledge  ;;汇报初始城市平均知识量
  if not initial_ave_u_knowledge_reported? [  ;;当未汇报初始城市平均知识量
    let all_agents (turtle-set citizens urban_volunteers)  ;;将市民和城市志愿者统一汇报
    set initial_average_urban_knowledge mean [knowledge] of all_agents  ;;取以上群体的初始平均知识量
    set initial_ave_u_knowledge_reported? true  ;;标记已汇报初始城市平均知识量，保证只汇报一次
  ]
  report initial_average_urban_knowledge  ;;将初始城市平均知识量赋值给report模块
end  ;;结束汇报初始城市平均知识量

;;汇报初始乡村平均知识量
to-report initial_ave_r_knowledge  ;;汇报初始乡村平均知识量
  if not initial_ave_r_knowledge_reported? [  ;;当未汇报初始乡村平均知识量
    let all_agents (turtle-set villagers rural_workers rural_gentrys)  ;;将村民、务工人员和乡村精英统一汇报
    set initial_average_rural_knowledge mean [knowledge] of all_agents  ;;取以上群体的初始平均知识量
    set initial_ave_r_knowledge_reported? true  ;;标记已汇报初始乡村平均知识量，保证只汇报一次
  ]
  report initial_average_rural_knowledge  ;;将初始乡村平均知识量赋值给report模块
end  ;;结束汇报初始乡村平均知识量

;;汇报初始城乡知识沟
to-report initial_u_r_knowledge_gap  ;;汇报初始城乡知识沟
  if not initial_u_r_knowledge_gap_reported? [  ;;当未汇报初始城乡知识沟
    let all_citizens (turtle-set citizens urban_volunteers)  ;;将市民和城市志愿者统一汇报为城市
    let ave_u_knowledge mean [knowledge] of all_citizens  ;;取以上群体的初始平均知识量
    let all_villagers (turtle-set villagers rural_workers rural_gentrys)  ;;将村民、务工人员和乡村精英统一汇报为乡村
    let ave_r_knowledge mean [knowledge] of all_villagers  ;;取以上群体的初始平均知识量
    let ini_u_r_knowledge_gap ave_u_knowledge / ave_r_knowledge  ;;求出初始城乡知识沟
    set initial_urban_rural_knowledge_gap ini_u_r_knowledge_gap  ;;保存初始城乡知识沟
    set initial_u_r_knowledge_gap_reported? true  ;;标记已汇报初始城乡知识沟，保证只汇报一次
  ]
  report initial_urban_rural_knowledge_gap  ;;将初始城乡知识沟赋值给report模块
end  ;;结束汇报初始城乡知识沟

;;汇报实时城市平均知识量
to-report average_urban_knowledge  ;;汇报实时城市平均知识量
  let all_agents (turtle-set citizens urban_volunteers)  ;;将市民和城市志愿者统一汇报
  report mean [knowledge] of all_agents  ;;汇报实时平均知识量并赋值给report模块
end  ;;结束汇报实时城市平均知识量

;;汇报实时乡村平均知识量
to-report average_rural_knowledge  ;;汇报实时乡村平均知识量
  let all_agents (turtle-set villagers rural_workers rural_gentrys)  ;;将村民、务工人员和乡村精英统一汇报
  report mean [knowledge] of all_agents  ;;汇报实时平均知识量并赋值给report模块
end  ;;结束汇报实时乡村平均知识量

;;汇报实时城乡知识沟
to-report urban_rural_knowledge_gap  ;;汇报实时城乡知识沟
  let all_citizens (turtle-set citizens urban_volunteers)  ;;将市民和城市志愿者统一汇报为城市
  let ave_u_knowledge mean [knowledge] of all_citizens  ;;取以上群体的初始平均知识量
  let all_villagers (turtle-set villagers rural_workers rural_gentrys)  ;;将村民、务工人员和乡村精英统一汇报为乡村
  let ave_r_knowledge mean [knowledge] of all_villagers  ;;取以上群体的初始平均知识量
  report ave_u_knowledge / ave_r_knowledge  ;;汇报实时城乡知识沟并赋值给report模块
end  ;;结束汇报实时城乡知识沟

;;汇报城乡知识沟最大值
to-report max_urban_rural_knowledge_gap_value  ;;汇报城乡知识沟最大值
  let all_citizens (turtle-set citizens urban_volunteers)  ;;将市民和城市志愿者统一汇报为城市
  let ave_u_knowledge mean [knowledge] of all_citizens  ;;取以上群体的初始平均知识量
  let all_villagers (turtle-set villagers rural_workers rural_gentrys)  ;;将村民、务工人员和乡村精英统一汇报为乡村
  let ave_r_knowledge mean [knowledge] of all_villagers  ;;取以上群体的初始平均知识量
  let u_r_knoledge_gap ave_u_knowledge / ave_r_knowledge  ;;取实时城乡知识沟

  ; 更新最高值
  if u_r_knoledge_gap > max_urban_rural_knowledge_gap [  ;;如果实时城乡知识沟大于初始设定的最大城乡知识沟即0
    set max_urban_rural_knowledge_gap u_r_knoledge_gap  ;;随时存储实时城乡知识沟到最大知识沟，也就是当实时的不再大于最大的，此时即为最大知识沟
  ]
  report max_urban_rural_knowledge_gap  ;;汇报最大城乡知识沟并赋值给report模块
end  ;;结束汇报城乡知识沟最大值

;;绘制城市知识占总知识的比重
to update_urban_knowledge_portion  ;;绘制城市知识占总知识的比重
  let urban_knowledge sum [knowledge] of citizens  ;;取全部市民知识总量
  let volunteer_knowledge sum [knowledge] of urban_volunteers  ;;取全部村民知识总量
  let sum_urban_knowledge urban_knowledge + volunteer_knowledge  ;;取城市知识总量
  set total_knowledge sum [knowledge] of turtles  ;;取全部智能体知识总量
  plot (sum_urban_knowledge / total_knowledge)  ;;绘制城市知识占总知识的比重
end  ;;结束绘制城市知识占总知识的比重

;;绘制乡村知识占总知识的比重
to update_rural_knowledge_portion  ;;绘制乡村知识占总知识的比重
  let rural_knowledge sum [knowledge] of villagers  ;;取全部村民知识总量
  let gentry_knowledge sum [knowledge] of rural_gentrys  ;;取全部乡村精英知识总量
  let worker_knowledge sum [knowledge] of rural_workers  ;;取全部务工人员知识总量
  let sum_rural_knowledge rural_knowledge + gentry_knowledge + worker_knowledge  ;;取乡村知识总量
  set total_knowledge sum [knowledge] of turtles  ;;取全部智能体知识总量
  plot (sum_rural_knowledge / total_knowledge)  ;;绘制乡村知识占总知识的比重
end  ;;结束绘制乡村知识占总知识的比重

;;绘制实时城乡知识沟
to update_urban_rural_knowledge_gap  ;;绘制实时城乡知识沟
  let all_citizens (turtle-set citizens urban_volunteers)  ;;将市民和城市志愿者统一汇报为城市
  let ave_u_knowledge mean [knowledge] of all_citizens  ;;取以上群体的初始平均知识量
  let all_villagers (turtle-set villagers rural_workers rural_gentrys)  ;;将村民、务工人员和乡村精英统一汇报为乡村
  let ave_r_knowledge mean [knowledge] of all_villagers  ;;取以上群体的初始平均知识量
  plot ave_u_knowledge / ave_r_knowledge  ;;绘制实时城乡知识沟
end  ;;结束绘制实时城乡知识沟

;;绘制城市知识量分配情况
to update_plot_urban_distribution  ;;绘制城市知识量分配情况
  let all-agents (turtle-set citizens urban_volunteers)  ;;将市民和城市志愿者统一汇报为城市
  let sorted-knowledge sort [knowledge] of all-agents  ;;按照知识量排序
  let n length sorted-knowledge  ;;计算智能体长度

  ;;计算基尼系数
  let total-knowledge sum sorted-knowledge
  let gini 0
  let i 0
  repeat n [
    let j 0
    repeat n [
      set gini gini + abs (item i sorted-knowledge - item j sorted-knowledge)
      set j j + 1
    ]
    set i i + 1
  ]
  set gini_citizens (gini / (2 * n * n * mean sorted-knowledge))
  plot gini_citizens  ; 绘制基尼系数
end  ;;结束绘制城市知识量分配情况

;;绘制乡村知识量分配情况
to update_plot_rural_distribution  ;;绘制乡村知识量分配情况
  let all-agents (turtle-set villagers rural_workers rural_gentrys)  ;;将村民、务工人员和乡村精英统一汇报为乡村
  let sorted-knowledge sort [knowledge] of all-agents  ;;按照知识量排序
  let n length sorted-knowledge  ;;计算智能体长度

  ;;计算基尼系数
  let total-knowledge sum sorted-knowledge
  let gini 0
  let i 0
  repeat n [
    let j 0
    repeat n [
      set gini gini + abs (item i sorted-knowledge - item j sorted-knowledge)
      set j j + 1
    ]
    set i i + 1
  ]
  set gini_villagers (gini / (2 * n * n * mean sorted-knowledge))
  plot gini_villagers  ; 绘制基尼系数
end  ;;结束绘制乡村知识量分配情况

;;汇报市民基尼系数
to-report gini_citizens_value  ;;汇报市民基尼系数
  report gini_citizens  ;;汇报市民基尼系数赋值给report模块
end  ;;结束汇报市民基尼系数

;;汇报村民基尼系数
to-report gini_villagers_value  ;;汇报村民基尼系数
  report gini_villagers  ;;汇报村民基尼系数赋值给report模块
end  ;;结束汇报村民基尼系数

;;汇报市民基尼系数最大值
to-report max_gini_citizens_value  ;;汇报市民基尼系数最大值
  if gini_citizens > max_gini_citizens [  ;;如果实时市民基尼系数大于初始设定的最大市民基尼系数即0
    set max_gini_citizens gini_citizens  ;;随时存储实时市民基尼系数到最大市民基尼系数，也就是当实时的不再大于最大的，此时即为最大市民基尼系数
  ]
  report max_gini_citizens  ;;汇报市民最大基尼系数赋值给report模块
end  ;;结束汇报市民基尼系数最大值

;;汇报村民基尼系数最大值
to-report max_gini_villagers_value  ;;汇报村民基尼系数最大值
  if gini_villagers > max_gini_villagers [  ;;如果实时村民基尼系数大于初始设定的最大村民基尼系数即0
    set max_gini_villagers gini_villagers  ;;随时存储实时村民基尼系数到最大村民基尼系数，也就是当实时的不再大于最大的，此时即为最大村民基尼系数
  ]
  report max_gini_villagers  ;;汇报村民最大基尼系数赋值给report模块
end  ;;结束汇报村民基尼系数最大值

;;============================================================

;;6. 存储数据到文件
;;定义文件存储路径、名称，写入数据

;;============================================================

;;存储数据到文件
to save_data  ;;存储数据到文件
  let file_path "D:\\"    ;;定义文件存储路径（注意转义反斜杠）
  let filename (word file_path "xxx.csv")  ;;设置文件名称
  file-open filename  ;;打开文件
  ;;写入表头
  file-print "initial_ave_u_knowledge, initial_ave_r_knowledge, initial_u_r_knowledge_gap, average_urban_knowledge, average_rural_knowledge, urban_rural_knowledge_gap, max_urban_rural_knowledge_gap, gini_citizens, gini_villagers, max_gini_citizens, max_gini_villagers"
  file-print (word    ;;写入当前数据（确保变量已定义，需加逗号分开）
    initial_ave_u_knowledge ","  ;;初始城市平均知识量
    initial_ave_r_knowledge ","  ;;初始乡村平均给知识量
    initial_u_r_knowledge_gap ","  ;;初始城乡知识沟
    average_urban_knowledge ","  ;;最终城市平均知识量
    average_rural_knowledge ","  ;;最终乡村平均知识量
    urban_rural_knowledge_gap ","  ;;最终城乡知识沟
    max_urban_rural_knowledge_gap ","  ;;城乡知识沟最大值
    gini_citizens ","  ;;最终城市基尼系数
    gini_villagers ","  ;;最终乡村基尼系数
    max_gini_citizens ","  ;;城市基尼系数最大值
    max_gini_villagers  ;;乡村基尼系数最大值
  )
  file-close  ;;关闭文件
end  ;;结束存储数据到文件
@#$#@#$#@
GRAPHICS-WINDOW
833
46
1634
453
-1
-1
3.95
1
10
1
1
1
0
0
0
1
-100
100
-50
50
0
0
1
ticks
30.0

BUTTON
365
204
431
237
NIL
setup\n
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

BUTTON
366
148
429
181
NIL
go\n
T
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

SWITCH
132
80
280
113
is_long_term?
is_long_term?
0
1
-1000

CHOOSER
512
79
650
124
urban_rural_mode
urban_rural_mode
"separated" "merged"
1

MONITOR
1031
547
1203
592
average_urban_knowledge
average_urban_knowledge
17
1
11

MONITOR
1031
598
1203
643
average_rural_knowledge
average_rural_knowledge
17
1
11

SWITCH
119
173
288
206
is_rural_gentry?
is_rural_gentry?
0
1
-1000

PLOT
60
542
405
799
城乡知识比例
NIL
NIL
0.0
10.0
0.0
2.0
true
true
"" ""
PENS
"城乡知识鸿沟" 1.0 0 -16777216 true "" "update_urban_rural_knowledge_gap"

PLOT
463
519
897
795
城乡知识量比重
NIL
NIL
0.0
10.0
0.0
1.0
true
true
"" ""
PENS
"城市比重" 1.0 0 -2674135 true "" "update_urban_knowledge_portion"
"乡村比重" 1.0 0 -13345367 true "" "update_rural_knowledge_portion"

SWITCH
111
214
307
247
is_urban_volunteers?
is_urban_volunteers?
0
1
-1000

MONITOR
1468
544
1571
589
gini_citizens
gini_citizens_value
17
1
11

MONITOR
1464
599
1574
644
gini_villagers
gini_villagers_value
17
1
11

PLOT
60
273
398
513
城乡知识量基尼系数
NIL
NIL
0.0
10.0
0.0
0.15
true
true
"" ""
PENS
"城市分配" 1.0 0 -2674135 true "" "update_plot_urban_distribution"
"乡村分配" 1.0 0 -13345367 true "" "update_plot_rural_distribution"

SLIDER
508
197
680
230
number_of_gentrys
number_of_gentrys
1
20
10.0
1
1
NIL
HORIZONTAL

SLIDER
502
236
690
269
number_of_volunteers
number_of_volunteers
1
20
10.0
1
1
NIL
HORIZONTAL

SWITCH
117
129
292
162
is_rural_workers?
is_rural_workers?
1
1
-1000

SLIDER
505
151
677
184
number_of_workers
number_of_workers
1
50
30.0
5
1
NIL
HORIZONTAL

BUTTON
363
101
429
134
start
start
NIL
1
T
OBSERVER
NIL
NIL
NIL
NIL
1

MONITOR
523
313
695
358
NIL
initial_ave_u_knowledge
17
1
11

MONITOR
522
366
694
411
NIL
initial_ave_r_knowledge
17
1
11

MONITOR
1022
650
1208
695
NIL
urban_rural_knowledge_gap
17
1
11

MONITOR
516
421
702
466
NIL
initial_u_r_knowledge_gap
17
1
11

MONITOR
999
701
1254
746
NIL
max_urban_rural_knowledge_gap_value
17
1
11

MONITOR
1433
656
1612
701
NIL
max_gini_villagers_value
17
1
11

MONITOR
1438
713
1610
758
NIL
max_gini_citizens_value
17
1
11

@#$#@#$#@
## WHAT IS IT?

(a general understanding of what the model is trying to show or explain)

## HOW IT WORKS

(what rules the agents use to create the overall behavior of the model)

## HOW TO USE IT

(how to use the model, including a description of each of the items in the Interface tab)

## THINGS TO NOTICE

(suggested things for the user to notice while running the model)

## THINGS TO TRY

(suggested things for the user to try to do (move sliders, switches, etc.) with the model)

## EXTENDING THE MODEL

(suggested things to add or change in the Code tab to make the model more complicated, detailed, accurate, etc.)

## NETLOGO FEATURES

(interesting or unusual features of NetLogo that the model uses, particularly in the Code tab; or where workarounds were needed for missing features)

## RELATED MODELS

(models in the NetLogo Models Library and elsewhere which are of related interest)

## CREDITS AND REFERENCES

(a reference to the model's URL on the web if it has one, as well as any other necessary credits, citations, and links)
@#$#@#$#@
default
true
0
Polygon -7500403 true true 150 5 40 250 150 205 260 250

airplane
true
0
Polygon -7500403 true true 150 0 135 15 120 60 120 105 15 165 15 195 120 180 135 240 105 270 120 285 150 270 180 285 210 270 165 240 180 180 285 195 285 165 180 105 180 60 165 15

arrow
true
0
Polygon -7500403 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150

box
false
0
Polygon -7500403 true true 150 285 285 225 285 75 150 135
Polygon -7500403 true true 150 135 15 75 150 15 285 75
Polygon -7500403 true true 15 75 15 225 150 285 150 135
Line -16777216 false 150 285 150 135
Line -16777216 false 150 135 15 75
Line -16777216 false 150 135 285 75

bug
true
0
Circle -7500403 true true 96 182 108
Circle -7500403 true true 110 127 80
Circle -7500403 true true 110 75 80
Line -7500403 true 150 100 80 30
Line -7500403 true 150 100 220 30

butterfly
true
0
Polygon -7500403 true true 150 165 209 199 225 225 225 255 195 270 165 255 150 240
Polygon -7500403 true true 150 165 89 198 75 225 75 255 105 270 135 255 150 240
Polygon -7500403 true true 139 148 100 105 55 90 25 90 10 105 10 135 25 180 40 195 85 194 139 163
Polygon -7500403 true true 162 150 200 105 245 90 275 90 290 105 290 135 275 180 260 195 215 195 162 165
Polygon -16777216 true false 150 255 135 225 120 150 135 120 150 105 165 120 180 150 165 225
Circle -16777216 true false 135 90 30
Line -16777216 false 150 105 195 60
Line -16777216 false 150 105 105 60

car
false
0
Polygon -7500403 true true 300 180 279 164 261 144 240 135 226 132 213 106 203 84 185 63 159 50 135 50 75 60 0 150 0 165 0 225 300 225 300 180
Circle -16777216 true false 180 180 90
Circle -16777216 true false 30 180 90
Polygon -16777216 true false 162 80 132 78 134 135 209 135 194 105 189 96 180 89
Circle -7500403 true true 47 195 58
Circle -7500403 true true 195 195 58

circle
false
0
Circle -7500403 true true 0 0 300

circle 2
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240

cow
false
0
Polygon -7500403 true true 200 193 197 249 179 249 177 196 166 187 140 189 93 191 78 179 72 211 49 209 48 181 37 149 25 120 25 89 45 72 103 84 179 75 198 76 252 64 272 81 293 103 285 121 255 121 242 118 224 167
Polygon -7500403 true true 73 210 86 251 62 249 48 208
Polygon -7500403 true true 25 114 16 195 9 204 23 213 25 200 39 123

cylinder
false
0
Circle -7500403 true true 0 0 300

dot
false
0
Circle -7500403 true true 90 90 120

face happy
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 255 90 239 62 213 47 191 67 179 90 203 109 218 150 225 192 218 210 203 227 181 251 194 236 217 212 240

face neutral
false
0
Circle -7500403 true true 8 7 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Rectangle -16777216 true false 60 195 240 225

face sad
false
0
Circle -7500403 true true 8 8 285
Circle -16777216 true false 60 75 60
Circle -16777216 true false 180 75 60
Polygon -16777216 true false 150 168 90 184 62 210 47 232 67 244 90 220 109 205 150 198 192 205 210 220 227 242 251 229 236 206 212 183

fish
false
0
Polygon -1 true false 44 131 21 87 15 86 0 120 15 150 0 180 13 214 20 212 45 166
Polygon -1 true false 135 195 119 235 95 218 76 210 46 204 60 165
Polygon -1 true false 75 45 83 77 71 103 86 114 166 78 135 60
Polygon -7500403 true true 30 136 151 77 226 81 280 119 292 146 292 160 287 170 270 195 195 210 151 212 30 166
Circle -16777216 true false 215 106 30

flag
false
0
Rectangle -7500403 true true 60 15 75 300
Polygon -7500403 true true 90 150 270 90 90 30
Line -7500403 true 75 135 90 135
Line -7500403 true 75 45 90 45

flower
false
0
Polygon -10899396 true false 135 120 165 165 180 210 180 240 150 300 165 300 195 240 195 195 165 135
Circle -7500403 true true 85 132 38
Circle -7500403 true true 130 147 38
Circle -7500403 true true 192 85 38
Circle -7500403 true true 85 40 38
Circle -7500403 true true 177 40 38
Circle -7500403 true true 177 132 38
Circle -7500403 true true 70 85 38
Circle -7500403 true true 130 25 38
Circle -7500403 true true 96 51 108
Circle -16777216 true false 113 68 74
Polygon -10899396 true false 189 233 219 188 249 173 279 188 234 218
Polygon -10899396 true false 180 255 150 210 105 210 75 240 135 240

house
false
0
Rectangle -7500403 true true 45 120 255 285
Rectangle -16777216 true false 120 210 180 285
Polygon -7500403 true true 15 120 150 15 285 120
Line -16777216 false 30 120 270 120

leaf
false
0
Polygon -7500403 true true 150 210 135 195 120 210 60 210 30 195 60 180 60 165 15 135 30 120 15 105 40 104 45 90 60 90 90 105 105 120 120 120 105 60 120 60 135 30 150 15 165 30 180 60 195 60 180 120 195 120 210 105 240 90 255 90 263 104 285 105 270 120 285 135 240 165 240 180 270 195 240 210 180 210 165 195
Polygon -7500403 true true 135 195 135 240 120 255 105 255 105 285 135 285 165 240 165 195

line
true
0
Line -7500403 true 150 0 150 300

line half
true
0
Line -7500403 true 150 0 150 150

pentagon
false
0
Polygon -7500403 true true 150 15 15 120 60 285 240 285 285 120

person
false
0
Circle -7500403 true true 110 5 80
Polygon -7500403 true true 105 90 120 195 90 285 105 300 135 300 150 225 165 300 195 300 210 285 180 195 195 90
Rectangle -7500403 true true 127 79 172 94
Polygon -7500403 true true 195 90 240 150 225 180 165 105
Polygon -7500403 true true 105 90 60 150 75 180 135 105

plant
false
0
Rectangle -7500403 true true 135 90 165 300
Polygon -7500403 true true 135 255 90 210 45 195 75 255 135 285
Polygon -7500403 true true 165 255 210 210 255 195 225 255 165 285
Polygon -7500403 true true 135 180 90 135 45 120 75 180 135 210
Polygon -7500403 true true 165 180 165 210 225 180 255 120 210 135
Polygon -7500403 true true 135 105 90 60 45 45 75 105 135 135
Polygon -7500403 true true 165 105 165 135 225 105 255 45 210 60
Polygon -7500403 true true 135 90 120 45 150 15 180 45 165 90

sheep
false
15
Circle -1 true true 203 65 88
Circle -1 true true 70 65 162
Circle -1 true true 150 105 120
Polygon -7500403 true false 218 120 240 165 255 165 278 120
Circle -7500403 true false 214 72 67
Rectangle -1 true true 164 223 179 298
Polygon -1 true true 45 285 30 285 30 240 15 195 45 210
Circle -1 true true 3 83 150
Rectangle -1 true true 65 221 80 296
Polygon -1 true true 195 285 210 285 210 240 240 210 195 210
Polygon -7500403 true false 276 85 285 105 302 99 294 83
Polygon -7500403 true false 219 85 210 105 193 99 201 83

square
false
0
Rectangle -7500403 true true 30 30 270 270

square 2
false
0
Rectangle -7500403 true true 30 30 270 270
Rectangle -16777216 true false 60 60 240 240

star
false
0
Polygon -7500403 true true 151 1 185 108 298 108 207 175 242 282 151 216 59 282 94 175 3 108 116 108

target
false
0
Circle -7500403 true true 0 0 300
Circle -16777216 true false 30 30 240
Circle -7500403 true true 60 60 180
Circle -16777216 true false 90 90 120
Circle -7500403 true true 120 120 60

tree
false
0
Circle -7500403 true true 118 3 94
Rectangle -6459832 true false 120 195 180 300
Circle -7500403 true true 65 21 108
Circle -7500403 true true 116 41 127
Circle -7500403 true true 45 90 120
Circle -7500403 true true 104 74 152

triangle
false
0
Polygon -7500403 true true 150 30 15 255 285 255

triangle 2
false
0
Polygon -7500403 true true 150 30 15 255 285 255
Polygon -16777216 true false 151 99 225 223 75 224

truck
false
0
Rectangle -7500403 true true 4 45 195 187
Polygon -7500403 true true 296 193 296 150 259 134 244 104 208 104 207 194
Rectangle -1 true false 195 60 195 105
Polygon -16777216 true false 238 112 252 141 219 141 218 112
Circle -16777216 true false 234 174 42
Rectangle -7500403 true true 181 185 214 194
Circle -16777216 true false 144 174 42
Circle -16777216 true false 24 174 42
Circle -7500403 false true 24 174 42
Circle -7500403 false true 144 174 42
Circle -7500403 false true 234 174 42

turtle
true
0
Polygon -10899396 true false 215 204 240 233 246 254 228 266 215 252 193 210
Polygon -10899396 true false 195 90 225 75 245 75 260 89 269 108 261 124 240 105 225 105 210 105
Polygon -10899396 true false 105 90 75 75 55 75 40 89 31 108 39 124 60 105 75 105 90 105
Polygon -10899396 true false 132 85 134 64 107 51 108 17 150 2 192 18 192 52 169 65 172 87
Polygon -10899396 true false 85 204 60 233 54 254 72 266 85 252 107 210
Polygon -7500403 true true 119 75 179 75 209 101 224 135 220 225 175 261 128 261 81 224 74 135 88 99

wheel
false
0
Circle -7500403 true true 3 3 294
Circle -16777216 true false 30 30 240
Line -7500403 true 150 285 150 15
Line -7500403 true 15 150 285 150
Circle -7500403 true true 120 120 60
Line -7500403 true 216 40 79 269
Line -7500403 true 40 84 269 221
Line -7500403 true 40 216 269 79
Line -7500403 true 84 40 221 269

wolf
false
0
Polygon -16777216 true false 253 133 245 131 245 133
Polygon -7500403 true true 2 194 13 197 30 191 38 193 38 205 20 226 20 257 27 265 38 266 40 260 31 253 31 230 60 206 68 198 75 209 66 228 65 243 82 261 84 268 100 267 103 261 77 239 79 231 100 207 98 196 119 201 143 202 160 195 166 210 172 213 173 238 167 251 160 248 154 265 169 264 178 247 186 240 198 260 200 271 217 271 219 262 207 258 195 230 192 198 210 184 227 164 242 144 259 145 284 151 277 141 293 140 299 134 297 127 273 119 270 105
Polygon -7500403 true true -1 195 14 180 36 166 40 153 53 140 82 131 134 133 159 126 188 115 227 108 236 102 238 98 268 86 269 92 281 87 269 103 269 113

x
false
0
Polygon -7500403 true true 270 75 225 30 30 225 75 270
Polygon -7500403 true true 30 75 75 30 270 225 225 270
@#$#@#$#@
NetLogo 6.4.0
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
default
0.0
-0.2 0 0.0 1.0
0.0 1 1.0 0.0
0.2 0 0.0 1.0
link direction
true
0
Line -7500403 true 150 150 90 180
Line -7500403 true 150 150 210 180
@#$#@#$#@
0
@#$#@#$#@
